You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mxnet.apache.org by GitBox <gi...@apache.org> on 2018/09/10 18:44:18 UTC
[GitHub] sandeep-krishnamurthy closed pull request #12376: [MXNET-854] SVRG
Optimization in Python Module API
sandeep-krishnamurthy closed pull request #12376: [MXNET-854] SVRG Optimization in Python Module API
URL: https://github.com/apache/incubator-mxnet/pull/12376
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/docs/api/python/contrib/svrg_optimization.md b/docs/api/python/contrib/svrg_optimization.md
new file mode 100644
index 00000000000..e6e1c3e23ee
--- /dev/null
+++ b/docs/api/python/contrib/svrg_optimization.md
@@ -0,0 +1,86 @@
+# SVRG Optimization in Python Module API
+
+## Overview
+SVRG which stands for Stochastic Variance Reduced Gradients, is an optimization technique that was first introduced in
+paper _Accelerating Stochastic Gradient Descent using Predictive Variance Reduction_ in 2013. It is complement to SGD
+(Stochastic Gradient Descent), which is known for large scale optimization but suffers from slow convergence
+asymptotically due to its inherent variance. SGD approximates the full gradients using a small batch of data or
+a single data sample, which will introduce variance and thus requires to start with a small learning rate in order to
+ensure convergence. SVRG remedies the problem by keeping track of a version of estimated weights that close to the
+optimal parameter values and maintaining an average of full gradients over a full pass of data. The average of full
+gradients is calculated with respect to the weights from the last m-th epochs in the training. SVRG uses a different
+update rule: gradients w.r.t current parameter values minus gradients w.r.t to parameters from the last m-th epochs
+plus the average of full gradients over all data.
+
+Key Characteristics of SVRG:
+* Employs explicit variance reduction by using a different update rule compared to SGD.
+* Ability to use relatively large learning rate, which leads to faster convergence compared to SGD.
+* Guarantees for fast convergence for smooth and strongly convex functions.
+
+SVRG optimization is implemented as a SVRGModule in `mxnet.contrib.svrg_optimization`, which is an extension of the
+existing `mxnet.module.Module` APIs and encapsulates SVRG optimization logic within several new functions. SVRGModule
+API changes compared to Module API to end users are minimal.
+
+In distributed training, each worker gets the same special weights from the last m-th epoch and calculates the full
+gradients with respect to its own shard of data. The standard SVRG optimization requires building a global full
+gradients, which is calculated by aggregating the full gradients from each worker and averaging over the number of
+workers. The workaround is to keep an additional set of keys in the KVStore that maps to full gradients.
+The `_SVRGOptimizer` is designed to wrap two optimizers, an `_AssignmentOptimizer` which is used for full gradients
+accumulation in the KVStore and a regular optimizer that performs actual update rule to the parameters.
+The `_SVRGOptimizer` and `_AssignmentOptimizer` are designed to be used in `SVRGModule` only.
+
+```eval_rst
+.. warning:: This package contains experimental APIs and may change in the near future.
+```
+
+This document lists the SVRGModule APIs in MXNet/Contrib package:
+
+```eval_rst
+.. autosummary::
+ :nosignatures:
+
+ mxnet.contrib.svrg_optimization.svrg_module
+```
+
+### Intermediate Level API for SVRGModule
+
+The only extra step to use a SVRGModule compared to use a Module is to check if the current epoch should update the
+full gradients over all data. Code snippets below demonstrate the suggested usage of SVRGModule using intermediate
+level APIs.
+
+```python
+>>> mod = SVRGModule(symbol=model, update_freq=2, data_names=['data'], label_names=['lin_reg_label'])
+>>> mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)
+>>> mod.init_params()
+>>> mod.init_optimizer(optimizer='sgd', optimizer_params=(('learning_rate', 0.01), ), kvstore='local')
+>>> for epoch in range(num_epochs):
+... if epoch % mod.update_freq == 0:
+... mod.update_full_grads(di)
+... di.reset()
+... for batch in di:
+... mod.forward_backward(data_batch=batch)
+... mod.update()
+```
+
+### High Level API for SVRGModule
+
+The high level API usage of SVRGModule remains exactly the same as Module API. Code snippets below gives an example of
+suggested usage of high level API.
+
+```python
+>>> mod = SVRGModule(symbol=model, update_freq=2, data_names=['data'], label_names=['lin_reg_label'])
+>>> mod.fit(di, num_epochs=100, optimizer='sgd', optimizer_params=(('learning_rate', 0.01), ))
+```
+
+## API reference
+
+<script type="text/javascript" src='../../../_static/js/auto_module_index.js'></script>
+
+```eval_rst
+
+.. automodule:: mxnet.contrib.svrg_optimization.svrg_module
+.. autoclass:: mxnet.contrib.svrg_optimization.svrg_module.SVRGModule
+ :members: init_optimizer, bind, forward, backward, reshape, update, update_full_grads, fit, prepare
+
+```
+<script>auto_index("api-reference");</script>
\ No newline at end of file
diff --git a/docs/api/python/index.md b/docs/api/python/index.md
index 42c4af9e46b..15d1045a93e 100644
--- a/docs/api/python/index.md
+++ b/docs/api/python/index.md
@@ -52,6 +52,7 @@ Code examples are placed throughout the API documentation and these can be run a
contrib/contrib.md
contrib/text.md
contrib/onnx.md
+ contrib/svrg_optimization.md
```
## Gluon API
@@ -176,4 +177,4 @@ Code examples are placed throughout the API documentation and these can be run a
:maxdepth: 1
symbol_in_pictures/symbol_in_pictures.md
-```
+```
\ No newline at end of file
diff --git a/docs/api/python/module/module.md b/docs/api/python/module/module.md
index 86ed74db6c1..5a874ac6df0 100644
--- a/docs/api/python/module/module.md
+++ b/docs/api/python/module/module.md
@@ -207,4 +207,4 @@ additional functionality. We summarize them in this section.
:members:
```
-<script>auto_index("api-reference");</script>
+<script>auto_index("api-reference");</script>
\ No newline at end of file
diff --git a/example/svrg_module/README.md b/example/svrg_module/README.md
new file mode 100644
index 00000000000..63e7ba2f2bf
--- /dev/null
+++ b/example/svrg_module/README.md
@@ -0,0 +1,33 @@
+## SVRGModule Example
+SVRGModule is an extension to the Module API that implements SVRG optimization, which stands for Stochastic
+Variance Reduced Gradient. SVRG is an optimization technique that complements SGD and has several key
+properties:
+* Employs explicit variance reduction by using a different update rule compared to SGD.
+* Ability to use relatively large learning rate, which leads to faster convergence compared to SGD.
+* Guarantees for fast convergence for smooth and strongly convex functions.
+
+#### API Usage Example
+SVRGModule provides both high-level and intermediate-level APIs while minimizing the changes with Module API.
+example_api_train.py: provides suggested usage of SVRGModule high-level and intermediate-level API.
+example_inference.py: provides example usage of SVRGModule inference.
+
+#### Linear Regression
+This example trains a linear regression model using SVRGModule on a real dataset, YearPredictionMSD.
+Logs of the training results can be found in experiments.log which will automatically generated when running the
+training script.
+
+##### Dataset
+YearPredictionMSD: contains predictions of the release year of a song from audio features. It has over
+400,000 samples with 90 features. Please uncomment data downloading script from data_reader.py to download the data.
+
+#### Benchmarks:
+An initial set of benchmarks has been performed on YearPredictionDatasetMSD with linear regression model. A jupyter
+notebook under `/benchmarks` demonstrates the training process and plots two graphs for benchmarking.
+
+* benchmark1: A lr_scheduler returns a new learning rate based on the number of updates that have been performed.
+
+* benchmark2: One drawback for SGD is that in order to converge faster, the learning rate has to decay to zero,
+thus SGD needs to start with a small learning rate. The learning rate does not need to decay to zero for SVRG,
+therefore we can use a relatively larger learning rate. SGD with learning rate of (0.001, 0.0025) and SVRG with
+learning rate of (0.025) are benchmarked. Even though SVRG starts with a relatively large learning rate, it converges
+much faster than SGD in both cases.
diff --git a/example/svrg_module/api_usage_example/example_api_train.py b/example/svrg_module/api_usage_example/example_api_train.py
new file mode 100644
index 00000000000..f6cd1b2e592
--- /dev/null
+++ b/example/svrg_module/api_usage_example/example_api_train.py
@@ -0,0 +1,124 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 mxnet as mx
+import numpy as np
+from mxnet.contrib.svrg_optimization.svrg_module import SVRGModule
+
+
+def test_svrg_intermediate_level_api(args):
+ """Demonstrates intermediate level SVRGModule API where the training process
+ need to be explicitly defined. KVstore is not explicitly created.
+
+ Parameters
+ ----------
+ args: args
+ Command line arguments
+ """
+ num_epoch = args.epochs
+ batch_size = args.batch_size
+ update_freq = args.update_freq
+
+ di, mod = create_network(batch_size, update_freq)
+
+ mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)
+ mod.init_params(initializer=mx.init.Uniform(0.01), allow_missing=False, force_init=False, allow_extra=False)
+ kv = mx.kv.create("local")
+ mod.init_optimizer(kvstore=kv, optimizer='sgd', optimizer_params=(('learning_rate', 0.025),))
+ metrics = mx.metric.create("mse")
+ for e in range(num_epoch):
+ metrics.reset()
+ if e % mod.update_freq == 0:
+ mod.update_full_grads(di)
+ di.reset()
+ for batch in di:
+ mod.forward_backward(data_batch=batch)
+ mod.update()
+ mod.update_metric(metrics, batch.label)
+ mod.logger.info('Epoch[%d] Train cost=%f', e, metrics.get()[1])
+
+
+def test_svrg_high_level_api(args):
+ """Demonstrates suggested usage of high level SVRGModule API. KVStore is explicitly created.
+
+ Parameters
+ ----------
+ args: args
+ Command line arguments
+ """
+ num_epoch = args.epochs
+ batch_size = args.batch_size
+ update_freq = args.update_freq
+
+ di, mod = create_network(batch_size, update_freq)
+ mod.fit(di, eval_metric='mse', optimizer='sgd', optimizer_params=(('learning_rate', 0.025),), num_epoch=num_epoch,
+ kvstore='local')
+
+
+def create_network(batch_size, update_freq):
+ """Create a linear regression network for performing SVRG optimization.
+ Parameters
+ ----------
+ batch_size: int
+ Size of data split
+ update_freq: int
+ Update Frequency for calculating full gradients
+
+ Returns
+ ----------
+ di: mx.io.NDArrayIter
+ Data iterator
+ update_freq: SVRGModule
+ An instance of SVRGModule for performing SVRG optimization
+ """
+ import logging
+ head = '%(asctime)-15s %(message)s'
+ logging.basicConfig(level=logging.INFO, format=head)
+
+ train_data = np.random.randint(1, 5, [1000, 2])
+ weights = np.array([1.0, 2.0])
+ train_label = train_data.dot(weights)
+
+ di = mx.io.NDArrayIter(train_data, train_label, batch_size=batch_size, shuffle=True, label_name='lin_reg_label')
+ X = mx.sym.Variable('data')
+ Y = mx.symbol.Variable('lin_reg_label')
+ fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1)
+ lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro")
+
+ mod = SVRGModule(
+ symbol=lro,
+ data_names=['data'],
+ label_names=['lin_reg_label'], update_freq=update_freq, logger=logging
+ )
+
+ return di, mod
+
+# run as a script
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-e', dest='epochs', default=100, type=int)
+ parser.add_argument('-bs', dest='batch_size', default=32, type=int)
+ parser.add_argument('-f', dest="update_freq", default=2, type=int)
+ args = parser.parse_args()
+
+ print("========================== Intermediate Level API ==========================")
+ test_svrg_intermediate_level_api(args)
+ print("========================== High Level API ==========================")
+ test_svrg_high_level_api(args)
diff --git a/example/svrg_module/api_usage_example/example_inference.py b/example/svrg_module/api_usage_example/example_inference.py
new file mode 100644
index 00000000000..312f9796074
--- /dev/null
+++ b/example/svrg_module/api_usage_example/example_inference.py
@@ -0,0 +1,106 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 mxnet as mx
+import numpy as np
+import logging
+from mxnet.contrib.svrg_optimization.svrg_module import SVRGModule
+
+
+def test_svrg_inference(args):
+ epoch = args.epochs
+ batch_size = args.batch_size
+ update_freq = args.update_freq
+
+ train_iter, val_iter, mod = create_network(batch_size, update_freq)
+ mod.fit(train_iter, eval_data=val_iter, eval_metric='mse', optimizer='sgd',
+ optimizer_params=(('learning_rate', 0.025),),
+ num_epoch=epoch)
+
+
+def get_validation_score(args):
+ epoch = args.epochs
+ batch_size = args.batch_size
+ update_freq = args.update_freq
+
+ train_iter, val_iter, mod = create_network(batch_size, update_freq)
+ mod.bind(data_shapes=train_iter.provide_data, label_shapes=train_iter.provide_label)
+ mod.init_params(initializer=mx.init.Uniform(0.01), allow_missing=False, force_init=False, allow_extra=False)
+ mod.init_optimizer(kvstore='local', optimizer='sgd', optimizer_params=(('learning_rate', 0.025),))
+ metrics = mx.metric.create("mse")
+ for e in range(epoch):
+ metrics.reset()
+ if e % mod.update_freq == 0:
+ mod.update_full_grads(train_iter)
+ train_iter.reset()
+ for batch in train_iter:
+ mod.forward_backward(data_batch=batch)
+ mod.update()
+ mod.update_metric(metrics, batch.label)
+
+ y = mod.predict(val_iter)
+
+ # test-train data split, 20% test data out of 1000 data samples
+ assert y.shape == (200, 1)
+ score = mod.score(val_iter, ['mse'])
+ print("Training Loss on Validation Set is {}".format(score[0][1]))
+
+
+def create_network(batch_size, update_freq):
+ """Create a linear regression network for performing SVRG optimization.
+ :return: an instance of mx.io.NDArrayIter
+ :return: an instance of mx.mod.svrgmodule for performing SVRG optimization
+ """
+ head = '%(asctime)-15s %(message)s'
+ logging.basicConfig(level=logging.INFO, format=head)
+ data = np.random.randint(1, 5, [1000, 2])
+
+ #Test_Train data split
+ n_train = int(data.shape[0] * 0.8)
+ weights = np.array([1.0, 2.0])
+ label = data.dot(weights)
+
+ di = mx.io.NDArrayIter(data[:n_train, :], label[:n_train], batch_size=batch_size, shuffle=True, label_name='lin_reg_label')
+ val_iter = mx.io.NDArrayIter(data[n_train:, :], label[n_train:], batch_size=batch_size)
+
+ X = mx.sym.Variable('data')
+ Y = mx.symbol.Variable('lin_reg_label')
+ fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1)
+ lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro")
+
+ mod = SVRGModule(
+ symbol=lro,
+ data_names=['data'],
+ label_names=['lin_reg_label'], update_freq=update_freq, logger=logging)
+
+ return di, val_iter, mod
+
+
+# run as a script
+if __name__ == "__main__":
+ import argparse
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-e', dest='epochs', default=100, type=int)
+ parser.add_argument('-bs', dest='batch_size', default=32, type=int)
+ parser.add_argument('-f', dest="update_freq", default=2, type=int)
+ args = parser.parse_args()
+
+ print("========================== SVRG Module Inference ==========================")
+ test_svrg_inference(args)
+ print("========================SVRG Module Score ============================")
+ get_validation_score(args)
diff --git a/example/svrg_module/benchmarks/svrg_benchmark.ipynb b/example/svrg_module/benchmarks/svrg_benchmark.ipynb
new file mode 100644
index 00000000000..db02938af46
--- /dev/null
+++ b/example/svrg_module/benchmarks/svrg_benchmark.ipynb
@@ -0,0 +1,379 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Linear Regression Using SVRGModule on YearPredictionMSD Dataset"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this notebook, a linear regression model will be fit on YearPredictionMSD dataset, which contains predictions of the release year of a song based on its audio features. The dataset has 90 features and over 400,000 samples. The dataset is downsampled to 5,000 in this experiment."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import mxnet as mx\n",
+ "from sklearn.datasets import load_svmlight_file\n",
+ "import numpy as np\n",
+ "import json\n",
+ "import tempfile\n",
+ "import os\n",
+ "from mxnet.contrib.svrg_optimization.svrg_module import SVRGModule\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Read Data\n",
+ "The first step is to get the training features and labels and normalize the data. In this example, we will use 5000 data samples. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Download data file\n",
+ "# from subprocess import call\n",
+ "# YearPredictionMSD dataset: https://archive.ics.uci.edu/ml/datasets/yearpredictionmsd\n",
+ "# call(['wget', 'https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/regression/YearPredictionMSD.bz2'])\n",
+ "# call(['bzip2', '-d', 'YearPredictionMSD.bz2'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reading data from disk...\n"
+ ]
+ }
+ ],
+ "source": [
+ "feature_dim = 90\n",
+ "print(\"Reading data from disk...\")\n",
+ "train_features, train_labels = load_svmlight_file('YearPredictionMSD', n_features=feature_dim, dtype=np.float32)\n",
+ "train_features = train_features.todense()\n",
+ "\n",
+ "# normalize the data: subtract means and divide by standard deviations\n",
+ "label_mean = train_labels.mean()\n",
+ "label_std = np.sqrt(np.square(train_labels - label_mean).mean())\n",
+ "feature_means = train_features.mean(axis=0)\n",
+ "feature_stds = np.sqrt(np.square(train_features - feature_means).mean(axis=0))\n",
+ "\n",
+ "train_features = (train_features - feature_means) / feature_stds\n",
+ "train_labels = (train_labels - label_mean) / label_std\n",
+ "\n",
+ "train_features = train_features[-5000:]\n",
+ "train_labels = train_labels[-5000:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Create Linear Regression Network"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def create_lin_reg_network(batch_size=100):\n",
+ " train_iter = mx.io.NDArrayIter(train_features, train_labels, batch_size=batch_size, shuffle=True,\n",
+ " data_name='data', label_name='label')\n",
+ " data = mx.sym.Variable(\"data\")\n",
+ " label = mx.sym.Variable(\"label\")\n",
+ " weight = mx.sym.Variable(\"fc_weight\", shape=(1, 90))\n",
+ " net = mx.sym.dot(data, weight.transpose())\n",
+ " bias = mx.sym.Variable(\"fc_bias\", shape=(1,), wd_mult=0.0, lr_mult=10.0)\n",
+ " net = mx.sym.broadcast_plus(net, bias)\n",
+ " net = mx.sym.LinearRegressionOutput(data=net, label=label)\n",
+ " \n",
+ " return train_iter, net"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### SVRGModule with SVRG Optimization\n",
+ "In this example, we will use intermediate level API for SVRGModule and the dump mse per epoch to JSON file for plotting graphs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def train_svrg_lin_reg(num_epoch=100, batch_size=100, update_freq=2, output='svrg_lr.json', \n",
+ " optimizer_params=None):\n",
+ "\n",
+ " di, net = create_lin_reg_network(batch_size=batch_size)\n",
+ " \n",
+ " #Create a SVRGModule\n",
+ " mod = SVRGModule(symbol=net, context=mx.cpu(0), data_names=['data'], label_names=['label'], update_freq=update_freq)\n",
+ " mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)\n",
+ " mod.init_params(initializer=mx.init.Zero(), allow_missing=False, force_init=False, allow_extra=False)\n",
+ " mod.init_optimizer(kvstore='local', optimizer='sgd', optimizer_params=optimizer_params)\n",
+ " metrics = mx.metric.create(\"mse\")\n",
+ " \n",
+ " results = {}\n",
+ " for e in range(num_epoch):\n",
+ " results[e] = {}\n",
+ " metrics.reset()\n",
+ " if e % mod.update_freq == 0:\n",
+ " mod.update_full_grads(di)\n",
+ " di.reset()\n",
+ " for batch in di:\n",
+ " mod.forward_backward(data_batch=batch)\n",
+ " mod.update()\n",
+ " mod.update_metric(metrics, batch.label)\n",
+ " results[e][\"mse\"] = metrics.get()[1]\n",
+ " \n",
+ " f = open(output, 'w+')\n",
+ " f.write(json.dumps(results, indent=4, sort_keys=True))\n",
+ " f.close()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Module with SGD Optimization "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def train_sgd_lin_reg(num_epoch=100, batch_size=100, update_freq=2, output='sgd_lr.json', \n",
+ " optimizer_params=None):\n",
+ " \n",
+ " di, net = create_lin_reg_network(batch_size=batch_size)\n",
+ " \n",
+ " #Create a standard module\n",
+ " mod = mx.mod.Module(symbol=net, context=mx.cpu(0), data_names=['data'], label_names=['label'])\n",
+ " mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)\n",
+ " mod.init_params(initializer=mx.init.Zero(), allow_missing=False, force_init=False, allow_extra=False)\n",
+ " mod.init_optimizer(kvstore='local', optimizer='sgd', optimizer_params=optimizer_params)\n",
+ " metrics = mx.metric.create(\"mse\")\n",
+ " \n",
+ " results = {}\n",
+ " for e in range(num_epoch):\n",
+ " results[e] = {}\n",
+ " metrics.reset()\n",
+ " di.reset()\n",
+ " for batch in di:\n",
+ " mod.forward_backward(data_batch=batch)\n",
+ " mod.update()\n",
+ " mod.update_metric(metrics, batch.label)\n",
+ " results[e][\"mse\"] = metrics.get()[1]\n",
+ " f = open(output, 'w+')\n",
+ " f.write(json.dumps(results, indent=4, sort_keys=True))\n",
+ " f.close()\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import json\n",
+ "import seaborn as sns\n",
+ "import matplotlib.pyplot as plt\n",
+ "import matplotlib.patches as mpatches\n",
+ "import pandas as pd"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training Loss over 100 Epochs Using lr_scheduler\n",
+ "When a large learning rate is used with SGD, training loss will drop fast but will oscillates above the minimum and never converges. With a small learning rate, it will eventually reach the minimum after many iterations. A common practice is to use learning rate scheduling by starting with a large learning rate and gradually decreasing it. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "train_svrg_lin_reg(optimizer_params={'lr_scheduler': mx.lr_scheduler.FactorScheduler(step=10, factor=0.99)})\n",
+ "train_sgd_lin_reg(optimizer_params={'lr_scheduler': mx.lr_scheduler.FactorScheduler(step=10, factor=0.99)})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Text(0.5,0,'Epochs')"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 1440x864 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plot graph\n",
+ "#Plot training loss over Epochs:\n",
+ "color = sns.color_palette()\n",
+ "#Draw Weight Variance Ratio\n",
+ "dataplot3 = {\"svrg_mse\": [], \"sgd_mse\": []}\n",
+ "with open('sgd_lr.json') as sgd_data, open('svrg_lr.json') as svrg_data:\n",
+ " sgd = json.load(sgd_data)\n",
+ " svrg = json.load(svrg_data)\n",
+ " for epoch in range(100):\n",
+ " dataplot3[\"svrg_mse\"].append(svrg[str(epoch)][\"mse\"])\n",
+ " dataplot3[\"sgd_mse\"].append(sgd[str(epoch)][\"mse\"])\n",
+ "\n",
+ "x3 = list(range(100))\n",
+ "plt.figure(figsize=(20, 12))\n",
+ "plt.title(\"Training Loss Over Epochs\")\n",
+ "sns.pointplot(x3, dataplot3['svrg_mse'], color=color[9])\n",
+ "sns.pointplot(x3, dataplot3['sgd_mse'], color=color[8])\n",
+ "color_patch1 = mpatches.Patch(color=color[9], label=\"svrg_mse\")\n",
+ "color_patch2 = mpatches.Patch(color=color[8], label=\"sgd_mse\")\n",
+ "plt.legend(handles=[color_patch1, color_patch2])\n",
+ "plt.ylabel('Training Loss', fontsize=12)\n",
+ "plt.xlabel('Epochs', fontsize=12)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training Loss Comparison with SGD with fixed learning rates\n",
+ "Choosing learning rate (0.0025, 0.001, 0.005) for SGD and a relatively large learning rate 0.025 for SVRG, we can see SVRG smoothly goes down faster than SGD. Learning rate for SVRG does not need to decay to zero, which means we can start with a larger learning rate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "train_svrg_lin_reg(output=\"svrg_0.025.json\", optimizer_params=(('learning_rate', 0.025),))\n",
+ "train_sgd_lin_reg(output=\"sgd_0.001.json\", optimizer_params=((\"learning_rate\", 0.001),))\n",
+ "train_sgd_lin_reg(output=\"sgd_0.0025.json\", optimizer_params=((\"learning_rate\", 0.0025),))\n",
+ "train_sgd_lin_reg(output=\"sgd_0.005.json\", optimizer_params=((\"learning_rate\", 0.005),))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Text(0.5,0,'Epochs')"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 1440x864 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#Plot training loss over Epochs:\n",
+ "color = sns.color_palette()\n",
+ "#Draw Weight Variance Ratio\n",
+ "dataplot3 = {\"svrg_mse\": [], \"sgd_mse_lr_0.001\": [], \"sgd_mse_lr_0.0025\": [], \"sgd_mse_lr_0.005\":[]}\n",
+ "with open('sgd_0.001.json') as sgd_data, open('svrg_0.025.json') as svrg_data, open('sgd_0.0025.json') as sgd_data_2, open('sgd_0.005.json') as sgd_data_3:\n",
+ " sgd = json.load(sgd_data)\n",
+ " svrg = json.load(svrg_data)\n",
+ " sgd_lr = json.load(sgd_data_2)\n",
+ " sgd_lr_2 = json.load(sgd_data_3)\n",
+ " for epoch in range(100):\n",
+ " dataplot3[\"svrg_mse\"].append(svrg[str(epoch)][\"mse\"])\n",
+ " dataplot3[\"sgd_mse_lr_0.001\"].append(sgd[str(epoch)][\"mse\"])\n",
+ " dataplot3[\"sgd_mse_lr_0.0025\"].append(sgd_lr[str(epoch)][\"mse\"])\n",
+ " dataplot3[\"sgd_mse_lr_0.005\"].append(sgd_lr_2[str(epoch)][\"mse\"])\n",
+ "\n",
+ "x3 = list(range(100))\n",
+ "plt.figure(figsize=(20, 12))\n",
+ "plt.title(\"Training Loss Over Epochs\")\n",
+ "sns.pointplot(x3, dataplot3['svrg_mse'], color=color[9])\n",
+ "sns.pointplot(x3, dataplot3['sgd_mse_lr_0.001'], color=color[8])\n",
+ "sns.pointplot(x3, dataplot3['sgd_mse_lr_0.0025'], color=color[3])\n",
+ "sns.pointplot(x3, dataplot3['sgd_mse_lr_0.005'], color=color[7])\n",
+ "color_patch1 = mpatches.Patch(color=color[9], label=\"svrg_mse_0.025\")\n",
+ "color_patch2 = mpatches.Patch(color=color[8], label=\"sgd_mse_lr_0.001\")\n",
+ "color_patch3 = mpatches.Patch(color=color[3], label=\"sgd_mse_lr_0.0025\")\n",
+ "color_patch4 = mpatches.Patch(color=color[7], label=\"sgd_mse_lr_0.005\")\n",
+ "plt.legend(handles=[color_patch1, color_patch2, color_patch3, color_patch4])\n",
+ "plt.ylabel('Training Loss', fontsize=12)\n",
+ "plt.xlabel('Epochs', fontsize=12)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 2",
+ "language": "python",
+ "name": "python2"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.15"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example/svrg_module/linear_regression/common.py b/example/svrg_module/linear_regression/common.py
new file mode 100644
index 00000000000..14a144f40ce
--- /dev/null
+++ b/example/svrg_module/linear_regression/common.py
@@ -0,0 +1,117 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 mxnet as mx
+import logging
+from mxnet.contrib.svrg_optimization.svrg_module import SVRGModule
+
+
+def create_lin_reg_network(train_features, train_labels, feature_dim, batch_size, update_freq, ctx, logger):
+ # fit a linear regression model with mxnet SVRGModule
+ print("Fitting linear regression with mxnet")
+ train_iter = mx.io.NDArrayIter(train_features, train_labels, batch_size=batch_size, shuffle=True,
+ data_name='data', label_name='label')
+ data = mx.sym.Variable("data")
+ label = mx.sym.Variable("label")
+ weight = mx.sym.Variable("fc_weight", shape=(1, feature_dim))
+ net = mx.sym.dot(data, weight.transpose())
+ bias = mx.sym.Variable("fc_bias", shape=(1,), wd_mult=0.0, lr_mult=10.0)
+ net = mx.sym.broadcast_plus(net, bias)
+ net = mx.sym.LinearRegressionOutput(data=net, label=label)
+ mod = SVRGModule(symbol=net, context=ctx, data_names=['data'], label_names=['label'], logger=logger,
+ update_freq=update_freq)
+ return train_iter, mod
+
+
+def create_metrics(metrics):
+ metric = mx.metric.create(metrics)
+ return metric
+
+
+def create_logger():
+ logger = logging.getLogger('sgd_svrg')
+ logger.setLevel(logging.INFO)
+ formatter = logging.Formatter('%(asctime)s - %(message)s')
+ fh = logging.FileHandler('experiments.log')
+ fh.setFormatter(formatter)
+ logger.addHandler(fh)
+ return logger
+
+
+################################################################################
+# Functions below are for benchmark purpose to calcuate expectation, variance of
+# gradients per epoch for each parameter. These calculations will be helpful when
+# benchmarking SVRG optimization with other optimization techniques, such as SGD.
+# Currently it only calculates the expectation, variance for single context but
+# can be extended to multi-context in later iterations.
+################################################################################
+
+def accumulate_grad(grad_dict, mod):
+ param_names = mod._exec_group.param_names
+
+ for index, name in enumerate(param_names):
+ if name not in grad_dict:
+ grad_dict[name] = mod._exec_group.grad_arrays[index][0].copy()
+ else:
+ grad_dict[name] = mx.ndarray.concat(grad_dict[name], mod._exec_group.grad_arrays[index][0], dim=0)
+
+
+def calc_expectation(grad_dict, num_batches):
+ """Calculates the expectation of the gradients per epoch for each parameter w.r.t number of batches
+
+ Parameters
+ ----------
+ grad_dict: dict
+ dictionary that maps parameter name to gradients in the mod executor group
+ num_batches: int
+ number of batches
+
+ Returns
+ ----------
+ grad_dict: dict
+ dictionary with new keys mapping to gradients expectations
+
+ """
+ for key in grad_dict.keys():
+ grad_dict[str.format(key+"_expectation")] = mx.ndarray.sum(grad_dict[key], axis=0) / num_batches
+
+ return grad_dict
+
+
+def calc_variance(grad_dict, num_batches, param_names):
+ """Calculates the variance of the gradients per epoch for each parameter w.r.t number of batches
+
+ Parameters
+ ----------
+ grad_dict: dict
+ dictionary that maps parameter name to gradients in the mod executor group
+ num_batches: int
+ number of batches
+ param_names: str
+ parameter name in the module
+
+ Returns
+ ----------
+ grad_dict: dict
+ dictionary with new keys mapping to gradients variance
+
+ """
+ for i in range(len(param_names)):
+ diff_sqr = mx.ndarray.square(mx.nd.subtract(grad_dict[param_names[i]],
+ grad_dict[str.format(param_names[i]+"_expectation")]))
+ grad_dict[str.format(param_names[i] + "_variance")] = mx.ndarray.sum(diff_sqr, axis=0) / num_batches
diff --git a/example/svrg_module/linear_regression/data_reader.py b/example/svrg_module/linear_regression/data_reader.py
new file mode 100644
index 00000000000..d56ae03a5f4
--- /dev/null
+++ b/example/svrg_module/linear_regression/data_reader.py
@@ -0,0 +1,45 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 numpy as np
+from sklearn.datasets import load_svmlight_file
+
+# Download data file
+# from subprocess import call
+# YearPredictionMSD dataset: https://archive.ics.uci.edu/ml/datasets/yearpredictionmsd
+# call(['wget', 'https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/regression/YearPredictionMSD.bz2'])
+# call(['bzip2', '-d', 'YearPredictionMSD.bz2'])
+
+
+def read_year_prediction_data(fileName):
+ feature_dim = 90
+ print("Reading data from disk...")
+ train_features, train_labels = load_svmlight_file(fileName, n_features=feature_dim, dtype=np.float32)
+ train_features = train_features.todense()
+
+ # normalize the data: subtract means and divide by standard deviations
+ label_mean = train_labels.mean()
+ label_std = np.sqrt(np.square(train_labels - label_mean).mean())
+ feature_means = train_features.mean(axis=0)
+ feature_stds = np.sqrt(np.square(train_features - feature_means).mean(axis=0))
+
+ train_features = (train_features - feature_means) / feature_stds
+ train_labels = (train_labels - label_mean) / label_std
+
+ return feature_dim, train_features, train_labels
+
diff --git a/example/svrg_module/linear_regression/train.py b/example/svrg_module/linear_regression/train.py
new file mode 100644
index 00000000000..b3d942973f1
--- /dev/null
+++ b/example/svrg_module/linear_regression/train.py
@@ -0,0 +1,45 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 argparse
+import mxnet as mx
+from common import create_lin_reg_network, create_logger
+from data_reader import read_year_prediction_data
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-e', dest='epochs', help='number of epochs for training phase', type=int, default=100)
+parser.add_argument('-f', dest="updateFreq", help="update frequency for SVRGModule", type=int, default=2)
+parser.add_argument('-b', dest="batch_size", help="define the batch size for training", type=int,
+ default=100, required=False)
+parser.add_argument('-m', dest='metrics', help="create eval metric", type=str, default='mse')
+parser.add_argument('--gpus', type=str, help='list of gpus to run, e.g. 0 or 0,2,5. empty means using cpu')
+parser.add_argument('--kv-store', type=str, default='local', help='key-value store type')
+
+args = parser.parse_args()
+# devices for training
+ctx = mx.cpu() if args.gpus is None or args.gpus == "" else [mx.gpu(int(i)) for i in args.gpus.split(',')]
+
+logger = create_logger()
+kv = mx.kvstore.create(args.kv_store)
+
+feature_dim, train_features, train_labels = read_year_prediction_data('YearPredictionMSD')
+train_iter, mod = create_lin_reg_network(train_features, train_labels, feature_dim, args.batch_size, args.updateFreq,
+ ctx, logger)
+
+mod.fit(train_iter, eval_metric='mse', optimizer='sgd',
+ optimizer_params=(('learning_rate', 0.025), ), num_epoch=args.epochs, kvstore=kv)
diff --git a/python/mxnet/contrib/svrg_optimization/__init__.py b/python/mxnet/contrib/svrg_optimization/__init__.py
new file mode 100644
index 00000000000..6e70009983c
--- /dev/null
+++ b/python/mxnet/contrib/svrg_optimization/__init__.py
@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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.
+"""SVRGModule, SVRGOptimization import.
+"""
+
+
+from . import svrg_module
+from . import svrg_optimizer
diff --git a/python/mxnet/contrib/svrg_optimization/svrg_module.py b/python/mxnet/contrib/svrg_optimization/svrg_module.py
new file mode 100644
index 00000000000..5d6b5dd5720
--- /dev/null
+++ b/python/mxnet/contrib/svrg_optimization/svrg_module.py
@@ -0,0 +1,578 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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.
+
+# coding: utf-8
+"""A `SVRGModule` implements the `Module` API by wrapping an auxiliary module to perform
+SVRG optimization logic.
+"""
+
+import time
+import logging
+import mxnet as mx
+from mxnet.module import Module
+from .svrg_optimizer import _SVRGOptimizer
+
+
+class SVRGModule(Module):
+ """SVRGModule is a module that encapsulates two Modules to accommodate the SVRG optimization technique.
+ It is functionally the same as Module API, except it is implemented using SVRG optimization logic.
+
+ Parameters
+ ----------
+ symbol : Symbol
+ data_names : list of str
+ Defaults to `('data')` for a typical model used in image classification.
+ label_names : list of str
+ Defaults to `('softmax_label')` for a typical model used in image
+ classification.
+ logger : Logger
+ Defaults to `logging`.
+ context : Context or list of Context
+ Defaults to ``mx.cpu()``.
+ work_load_list : list of number
+ Default ``None``, indicating uniform workload.
+ fixed_param_names: list of str
+ Default ``None``, indicating no network parameters are fixed.
+ state_names : list of str
+ states are similar to data and label, but not provided by data iterator.
+ Instead they are initialized to 0 and can be set by `set_states()`.
+ group2ctxs : dict of str to context or list of context, or list of dict of str to context
+ Default is `None`. Mapping the `ctx_group` attribute to the context assignment.
+ compression_params : dict
+ Specifies type of gradient compression and additional arguments depending
+ on the type of compression being used. For example, 2bit compression requires a threshold.
+ Arguments would then be {'type':'2bit', 'threshold':0.5}
+ See mxnet.KVStore.set_gradient_compression method for more details on gradient compression.
+ update_freq: int
+ Specifies the number of times to update the full gradients to be used in the SVRG optimization. For instance,
+ update_freq = 2 will calculates the gradients over all data every two epochs
+ Examples
+ --------
+ >>> # An example of declaring and using SVRGModule.
+ >>> mod = SVRGModule(symbol=lro, data_names=['data'], label_names=['lin_reg_label'], update_freq=2)
+ >>> mod.fit(di, eval_metric='mse', optimizer='sgd', optimizer_params=(('learning_rate', 0.025),),
+ >>> num_epoch=num_epoch, kvstore='local')
+ """
+
+ def __init__(self, symbol, data_names=('data',), label_names=('softmax_label',),
+ logger=logging, context=mx.cpu(), work_load_list=None,
+ fixed_param_names=None, state_names=None, group2ctxs=None,
+ compression_params=None, update_freq=None):
+ super(SVRGModule, self).__init__(symbol, data_names=data_names, label_names=label_names, logger=logger,
+ context=context, work_load_list=work_load_list,
+ fixed_param_names=fixed_param_names, state_names=state_names,
+ group2ctxs=group2ctxs, compression_params=compression_params)
+
+ # Type check update_frequency
+ if isinstance(update_freq, int):
+ if update_freq <= 0:
+ raise ValueError("update_freq in SVRGModule must be a positive integer to represent the frequency for "
+ "calculating full gradients")
+ self.update_freq = update_freq
+ else:
+ raise TypeError("update_freq in SVRGModule must be an integer to represent the frequency for "
+ "calculating full gradients")
+
+ self._mod_aux = mx.mod.Module(symbol, data_names, label_names, logger, context, work_load_list,
+ fixed_param_names, state_names, group2ctxs, compression_params)
+
+ self._param_dict = None
+ self._ctx_len = len(self._context)
+
+ def _reset_bind(self):
+ """Internal function to reset binded state for both modules."""
+ super(SVRGModule, self)._reset_bind()
+ self._mod_aux._reset_bind()
+
+ def reshape(self, data_shapes, label_shapes=None):
+ """Reshapes both modules for new input shapes.
+
+ Parameters
+ ----------
+ data_shapes : list of (str, tuple)
+ Typically is ``data_iter.provide_data``.
+ label_shapes : list of (str, tuple)
+ Typically is ``data_iter.provide_label``.
+ """
+ super(SVRGModule, self).reshape(data_shapes, label_shapes=label_shapes)
+ self._mod_aux.reshape(data_shapes, label_shapes=label_shapes)
+
+ def init_optimizer(self, kvstore='local', optimizer='sgd',
+ optimizer_params=(('learning_rate', 0.01),), force_init=False):
+ """Installs and initializes SVRGOptimizer. The SVRGOptimizer is a wrapper class for a regular optimizer that is
+ passed in and a special AssignmentOptimizer to accumulate the full gradients. If KVStore is 'local' or None,
+ the full gradients will be accumulated locally without pushing to the KVStore. Otherwise, additional keys will
+ be pushed to accumulate the full gradients in the KVStore.
+
+ Parameters
+ ----------
+ kvstore : str or KVStore
+ Default `'local'`.
+ optimizer : str or Optimizer
+ Default `'sgd'`
+ optimizer_params : dict
+ Default `(('learning_rate', 0.01),)`. The default value is not a dictionary,
+ just to avoid pylint warning of dangerous default values.
+ force_init : bool
+ Default ``False``, indicating whether we should force re-initializing the
+ optimizer in the case an optimizer is already installed.
+ """
+
+ # Init dict for storing average of full gradients for each device
+ self._param_dict = [{key: mx.nd.zeros(shape=value.shape, ctx=self._context[i])
+ for key, value in self.get_params()[0].items()} for i in range(self._ctx_len)]
+
+ svrg_optimizer = self._create_optimizer(_SVRGOptimizer.__name__, default_opt=optimizer,
+ kvstore=kvstore, optimizer_params=optimizer_params)
+
+ super(SVRGModule, self).init_optimizer(kvstore=kvstore, optimizer=svrg_optimizer,
+ optimizer_params=optimizer_params, force_init=force_init)
+
+ # Init additional keys for accumulating full grads in KVStore
+ if self._kvstore:
+ for idx, param_on_devs in enumerate(self._exec_group.param_arrays):
+ name = self._exec_group.param_names[idx]
+ self._kvstore.init(name + "_full", mx.nd.zeros(shape=self._arg_params[name].shape))
+ if self._update_on_kvstore:
+ self._kvstore.pull(name + "_full", param_on_devs, priority=-idx)
+
+ def _create_optimizer(self, optimizer, default_opt, kvstore, optimizer_params):
+ """Helper function to create a svrg optimizer. SVRG optimizer encapsulates two optimizers and
+ will redirect update() to the correct optimizer based on the key.
+
+ Parameters
+ ----------
+ kvstore : str or KVStore
+ Default `'local'`.
+ optimizer: str
+ Name for SVRGOptimizer
+ default_opt : str or Optimizer that was passed in.
+ optimizer_params : dict
+ optimizer params that was passed in.
+ """
+
+ # code partially copied from mxnet module.init_optimizer() to accomodate svrg_optimizer
+ batch_size = self._exec_group.batch_size
+
+ (kv_store, update_on_kvstore) = mx.model._create_kvstore(kvstore, self._ctx_len, self._arg_params)
+ if kv_store and 'dist' in kv_store.type and '_sync' in kv_store.type:
+ batch_size *= kv_store.num_workers
+ rescale_grad = 1.0 / batch_size
+
+ idx2name = {}
+ if update_on_kvstore:
+ idx2name.update(enumerate(self._exec_group.param_names))
+ else:
+ for k in range(self._ctx_len):
+ idx2name.update({i * self._ctx_len + k: n
+ for i, n in enumerate(self._exec_group.param_names)})
+
+ # update idx2name to include new keys
+ for key in self._param_dict[0].keys():
+ max_key = max(list(idx2name.keys())) + 1
+ idx2name[max_key] = key + "_full"
+
+ optimizer_params = dict(optimizer_params)
+ if 'rescale_grad' not in optimizer_params:
+ optimizer_params['rescale_grad'] = rescale_grad
+ optimizer_params["default_optimizer"] = default_opt
+ optimizer_params["param_idx2name"] = idx2name
+ optimizer = mx.optimizer.create(optimizer, **optimizer_params)
+
+ return optimizer
+
+ def bind(self, data_shapes, label_shapes=None, for_training=True,
+ inputs_need_grad=False, force_rebind=False, shared_module=None, grad_req='write'):
+ """Binds the symbols to construct executors for both two modules. This is necessary before one
+ can perform computation with the SVRGModule.
+
+ Parameters
+ ----------
+ data_shapes : list of (str, tuple)
+ Typically is ``data_iter.provide_data``.
+ label_shapes : list of (str, tuple)
+ Typically is ``data_iter.provide_label``.
+ for_training : bool
+ Default is ``True``. Whether the executors should be bound for training.
+ inputs_need_grad : bool
+ Default is ``False``. Whether the gradients to the input data need to be computed.
+ Typically this is not needed. But this might be needed when implementing composition
+ of modules.
+ force_rebind : bool
+ Default is ``False``. This function does nothing if the executors are already
+ bound. But with this ``True``, the executors will be forced to rebind.
+ shared_module : Module
+ Default is ``None``. This is used in bucketing. When not ``None``, the shared module
+ essentially corresponds to a different bucket -- a module with different symbol
+ but with the same sets of parameters (e.g. unrolled RNNs with different lengths).
+ """
+ # force rebinding is typically used when one want to switch from
+ # training to prediction phase.
+ super(SVRGModule, self).bind(data_shapes, label_shapes, for_training, inputs_need_grad, force_rebind,
+ shared_module, grad_req)
+
+ if for_training:
+ self._mod_aux.bind(data_shapes, label_shapes, for_training, inputs_need_grad, force_rebind, shared_module,
+ grad_req)
+
+ def forward(self, data_batch, is_train=None):
+ """Forward computation for both two modules. It supports data batches with different shapes, such as
+ different batch sizes or different image sizes.
+ If reshaping of data batch relates to modification of symbol or module, such as
+ changing image layout ordering or switching from training to predicting, module
+ rebinding is required.
+
+ See Also
+ ----------
+ :meth:`BaseModule.forward`.
+
+ Parameters
+ ----------
+ data_batch : DataBatch
+ Could be anything with similar API implemented.
+ is_train : bool
+ Default is ``None``, which means ``is_train`` takes the value of ``self.for_training``.
+ """
+ super(SVRGModule, self).forward(data_batch, is_train)
+
+ if is_train:
+ self._mod_aux.forward(data_batch, is_train)
+
+ def backward(self, out_grads=None):
+ """Backward computation.
+
+ See Also
+ ----------
+ :meth:`BaseModule.backward`.
+
+ Parameters
+ ----------
+ out_grads : NDArray or list of NDArray, optional
+ Gradient on the outputs to be propagated back.
+ This parameter is only needed when bind is called
+ on outputs that are not a loss function.
+ """
+ super(SVRGModule, self).backward(out_grads)
+
+ if self._mod_aux.binded:
+ self._mod_aux.backward(out_grads)
+
+ def update(self):
+ """Updates parameters according to the installed optimizer and the gradients computed
+ in the previous forward-backward batch. The gradients in the _exec_group will be overwritten
+ using the gradients calculated by the SVRG update rule.
+
+ When KVStore is used to update parameters for multi-device or multi-machine training,
+ a copy of the parameters is stored in KVStore. Note that for `row_sparse` parameters,
+ this function does update the copy of parameters in KVStore, but doesn't broadcast the
+ updated parameters to all devices / machines. Please call `prepare` to broadcast
+ `row_sparse` parameters with the next batch of data.
+
+ See Also
+ ----------
+ :meth:`BaseModule.update`.
+ """
+ self._update_svrg_gradients()
+ super(SVRGModule, self).update()
+
+ def update_full_grads(self, train_data):
+ """Computes the gradients over all data w.r.t weights of past
+ m epochs. For distributed env, it will accumulate full grads in the kvstore.
+
+ Parameters
+ ----------
+ train_data: DataIter
+ Train data iterator
+ """
+ param_names = self._exec_group.param_names
+ arg, aux = self.get_params()
+ self._mod_aux.set_params(arg_params=arg, aux_params=aux)
+ train_data.reset()
+ nbatch = 0
+ padding = 0
+ for batch in train_data:
+ self._mod_aux.forward(batch, is_train=True)
+ self._mod_aux.backward()
+ nbatch += 1
+ for ctx in range(self._ctx_len):
+ for index, name in enumerate(param_names):
+ grads = self._mod_aux._exec_group.grad_arrays[index][ctx]
+ self._param_dict[ctx][name] = mx.nd.broadcast_add(self._param_dict[ctx][name], grads, axis=0)
+ padding = batch.pad
+
+ true_num_batch = nbatch - padding / train_data.batch_size
+ for name in param_names:
+ grad_list = []
+ for i in range(self._ctx_len):
+ self._param_dict[i][name] /= true_num_batch
+ grad_list.append(self._param_dict[i][name])
+ if self._kvstore:
+ # If in distributed mode, push a list of gradients from each worker/device to the KVStore
+ self._accumulate_kvstore(name, grad_list)
+
+ def _accumulate_kvstore(self, key, value):
+ """Accumulate gradients over all data in the KVStore. In distributed setting, each worker sees a portion of
+ data. The full gradients will be aggregated from each worker in the KVStore.
+
+ Parameters
+ ----------
+
+ key: int or str
+ Key in the KVStore.
+ value: NDArray, RowSparseNDArray
+ Average of the full gradients.
+ """
+ # Accumulate full gradients for current epochs
+ self._kvstore.push(key + "_full", value)
+ self._kvstore._barrier()
+ self._kvstore.pull(key + "_full", value)
+
+ self._allocate_gradients(key, value)
+
+ def _allocate_gradients(self, key, value):
+ """Allocate average of full gradients accumulated in the KVStore to each device.
+
+ Parameters
+ ----------
+
+ key: int or str
+ Key in the kvstore.
+ value: List of NDArray, List of RowSparseNDArray
+ A list of average of the full gradients in the KVStore.
+ """
+ for i in range(self._ctx_len):
+ self._param_dict[i][key] = value[i] / self._ctx_len
+
+ def _svrg_grads_update_rule(self, g_curr_batch_curr_weight, g_curr_batch_special_weight,
+ g_special_weight_all_batch):
+ """Calculates the gradient based on the SVRG update rule.
+ Parameters
+ ----------
+ g_curr_batch_curr_weight : NDArray
+ gradients of current weight of self.mod w.r.t current batch of data
+ g_curr_batch_special_weight: NDArray
+ gradients of the weight of past m epochs of self._mod_special w.r.t current batch of data
+ g_special_weight_all_batch: NDArray
+ average of full gradients over full pass of data
+
+ Returns
+ ----------
+ Gradients calculated using SVRG update rule:
+ grads = g_curr_batch_curr_weight - g_curr_batch_special_weight + g_special_weight_all_batch
+ """
+ for index, grad in enumerate(g_curr_batch_curr_weight):
+ grad -= g_curr_batch_special_weight[index]
+ grad += g_special_weight_all_batch[index]
+ return g_curr_batch_curr_weight
+
+ def _update_svrg_gradients(self):
+ """Calculates gradients based on the SVRG update rule.
+ """
+ param_names = self._exec_group.param_names
+ for ctx in range(self._ctx_len):
+ for index, name in enumerate(param_names):
+ g_curr_batch_reg = self._exec_group.grad_arrays[index][ctx]
+ g_curr_batch_special = self._mod_aux._exec_group.grad_arrays[index][ctx]
+ g_special_weight_all_batch = self._param_dict[ctx][name]
+ g_svrg = self._svrg_grads_update_rule(g_curr_batch_reg, g_curr_batch_special,
+ g_special_weight_all_batch)
+ self._exec_group.grad_arrays[index][ctx] = g_svrg
+
+ def fit(self, train_data, eval_data=None, eval_metric='acc',
+ epoch_end_callback=None, batch_end_callback=None, kvstore='local',
+ optimizer='sgd', optimizer_params=(('learning_rate', 0.01),),
+ eval_end_callback=None,
+ eval_batch_end_callback=None, initializer=mx.init.Uniform(0.01),
+ arg_params=None, aux_params=None, allow_missing=False,
+ force_rebind=False, force_init=False, begin_epoch=0, num_epoch=None,
+ validation_metric=None, monitor=None, sparse_row_id_fn=None):
+ """Trains the module parameters.
+ Parameters
+ ----------
+ train_data : DataIter
+ Train DataIter.
+ eval_data : DataIter
+ If not ``None``, will be used as validation set and the performance
+ after each epoch will be evaluated.
+ eval_metric : str or EvalMetric
+ Defaults to 'accuracy'. The performance measure used to display during training.
+ Other possible predefined metrics are:
+ 'ce' (CrossEntropy), 'f1', 'mae', 'mse', 'rmse', 'top_k_accuracy'.
+ epoch_end_callback : function or list of functions
+ Each callback will be called with the current `epoch`, `symbol`, `arg_params`
+ and `aux_params`.
+ batch_end_callback : function or list of function
+ Each callback will be called with a `BatchEndParam`.
+ kvstore : str or KVStore
+ Defaults to 'local'.
+ optimizer : str or Optimizer
+ Defaults to 'sgd'.
+ optimizer_params : dict
+ Defaults to ``(('learning_rate', 0.01),)``. The parameters for
+ the optimizer constructor.
+ The default value is not a dict, just to avoid pylint warning on dangerous
+ default values.
+ eval_end_callback : function or list of function
+ These will be called at the end of each full evaluation, with the metrics over
+ the entire evaluation set.
+ eval_batch_end_callback : function or list of function
+ These will be called at the end of each mini-batch during evaluation.
+ initializer : Initializer
+ The initializer is called to initialize the module parameters when they are
+ not already initialized.
+ arg_params : dict
+ Defaults to ``None``, if not ``None``, should be existing parameters from a trained
+ model or loaded from a checkpoint (previously saved model). In this case,
+ the value here will be used to initialize the module parameters, unless they
+ are already initialized by the user via a call to `init_params` or `fit`.
+ `arg_params` has a higher priority than `initializer`.
+ aux_params : dict
+ Defaults to ``None``. Similar to `arg_params`, except for auxiliary states.
+ allow_missing : bool
+ Defaults to ``False``. Indicates whether to allow missing parameters when `arg_params`
+ and `aux_params` are not ``None``. If this is ``True``, then the missing parameters
+ will be initialized via the `initializer`.
+ force_rebind : bool
+ Defaults to ``False``. Whether to force rebinding the executors if already bound.
+ force_init : bool
+ Defaults to ``False``. Indicates whether to force initialization even if the
+ parameters are already initialized.
+ begin_epoch : int
+ Defaults to 0. Indicates the starting epoch. Usually, if resumed from a
+ checkpoint saved at a previous training phase at epoch N, then this value should be
+ N+1.
+ num_epoch : int
+ Number of epochs for training.
+ sparse_row_id_fn : A callback function
+ The function takes `data_batch` as an input and returns a dict of
+ str -> NDArray. The resulting dict is used for pulling row_sparse
+ parameters from the kvstore, where the str key is the name of the param,
+ and the value is the row id of the param to pull.
+ validation_metric: str or EvalMetric
+ The performance measure used to display during validation.
+ """
+ assert num_epoch is not None, 'please specify number of epochs'
+
+ self.bind(data_shapes=train_data.provide_data, label_shapes=train_data.provide_label,
+ for_training=True, force_rebind=force_rebind)
+ if monitor is not None:
+ self.install_monitor(monitor)
+ self.init_params(initializer=initializer, arg_params=arg_params, aux_params=aux_params,
+ allow_missing=allow_missing, force_init=force_init)
+ self.init_optimizer(kvstore=kvstore, optimizer=optimizer, optimizer_params=optimizer_params)
+
+ if validation_metric is None:
+ validation_metric = eval_metric
+ if not isinstance(eval_metric, mx.metric.EvalMetric):
+ eval_metric = mx.metric.create(eval_metric)
+
+ ################################################################################
+ # training loop
+ ################################################################################
+ for epoch in range(begin_epoch, num_epoch):
+ eval_metric.reset()
+ tic = time.time()
+ if epoch % self.update_freq == 0:
+ self.update_full_grads(train_data)
+
+ train_data.reset()
+ data_iter = iter(train_data)
+ end_of_batch = False
+ nbatch = 0
+ next_data_batch = next(data_iter)
+
+ while not end_of_batch:
+ data_batch = next_data_batch
+ if monitor is not None:
+ monitor.tic()
+
+ self.forward_backward(data_batch)
+ self.update()
+
+ if isinstance(data_batch, list):
+ self.update_metric(eval_metric, [db.label for db in data_batch], pre_sliced=True)
+ else:
+ self.update_metric(eval_metric, data_batch.label)
+
+ try:
+ # pre fetch next batch
+ next_data_batch = next(data_iter)
+ self.prepare(next_data_batch, sparse_row_id_fn=sparse_row_id_fn)
+ except StopIteration:
+ end_of_batch = True
+
+ if monitor is not None:
+ monitor.toc_print()
+
+ if end_of_batch:
+ eval_name_vals = eval_metric.get_name_value()
+
+ if batch_end_callback is not None:
+ batch_end_params = mx.model.BatchEndParam(epoch=epoch, nbatch=nbatch,
+ eval_metric=eval_metric, locals=locals())
+ for callback in mx.base._as_list(batch_end_callback):
+ callback(batch_end_params)
+
+ nbatch += 1
+ for name, val in eval_name_vals:
+ self.logger.info('Epoch[%d] Train-%s=%f', epoch, name, val)
+ toc = time.time()
+ self.logger.info('Epoch[%d] Time cost=%.3f', epoch, (toc - tic))
+
+ # sync aux params across devices
+ arg_params, aux_params = self.get_params()
+ self.set_params(arg_params, aux_params)
+
+ if epoch_end_callback is not None:
+ for callback in mx.base._as_list(epoch_end_callback):
+ callback(epoch, self.symbol, arg_params, aux_params)
+
+ # ----------------------------------------
+ # evaluation on validation set
+ if eval_data:
+ res = self.score(eval_data, validation_metric,
+ score_end_callback=eval_end_callback,
+ batch_end_callback=eval_batch_end_callback, epoch=epoch)
+ for name, val in res:
+ self.logger.info('Epoch[%d] Validation-%s=%f', epoch, name, val)
+
+ def prepare(self, data_batch, sparse_row_id_fn=None):
+ """Prepares two modules for processing a data batch.
+
+ Usually involves switching bucket and reshaping.
+ For modules that contain `row_sparse` parameters in KVStore,
+ it prepares the `row_sparse` parameters based on the sparse_row_id_fn.
+
+ When KVStore is used to update parameters for multi-device or multi-machine training,
+ a copy of the parameters are stored in KVStore. Note that for `row_sparse` parameters,
+ the `update()` updates the copy of parameters in KVStore, but doesn't broadcast
+ the updated parameters to all devices / machines. The `prepare` function is used to
+ broadcast `row_sparse` parameters with the next batch of data.
+
+ Parameters
+ ----------
+ data_batch : DataBatch
+ The current batch of data for forward computation.
+
+ sparse_row_id_fn : A callback function
+ The function takes `data_batch` as an input and returns a dict of
+ str -> NDArray. The resulting dict is used for pulling row_sparse
+ parameters from the kvstore, where the str key is the name of the param,
+ and the value is the row id of the param to pull.
+ """
+ super(SVRGModule, self).prepare(data_batch, sparse_row_id_fn=sparse_row_id_fn)
+ self._mod_aux.prepare(data_batch, sparse_row_id_fn=sparse_row_id_fn)
diff --git a/python/mxnet/contrib/svrg_optimization/svrg_optimizer.py b/python/mxnet/contrib/svrg_optimization/svrg_optimizer.py
new file mode 100644
index 00000000000..0f695a1b2ff
--- /dev/null
+++ b/python/mxnet/contrib/svrg_optimization/svrg_optimizer.py
@@ -0,0 +1,171 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 `_SVRGOptimizer` encapsulates two optimizers to support SVRGModule in single machine and distributed settings.
+Both `_AssignmentOptimizer` and `_SVRGOptimizer` are designed to be used with SVRGModule only.
+"""
+
+
+import mxnet as mx
+
+
+@mx.optimizer.register
+class _AssignmentOptimizer(mx.optimizer.Optimizer):
+ """_AssignmentOptimizer assigns gradients to weights for SVRGModule's full gradients
+ accumulation in the KVStore. It is a helper optimizer that is designed to be used with SVRGModule only.
+ """
+ def update(self, index, weight, grad, state):
+ """Assign the gradients to weight for accumulating full gradients in the KVStore across all devices and workers.
+
+ Parameters
+ ----------
+ index : int
+ The unique index of the parameter into the individual learning
+ rates and weight decays. Learning rates and weight decay
+ may be set via `set_lr_mult()` and `set_wd_mult()`, respectively.
+ weight : NDArray
+ The parameter to be updated.
+ grad : NDArray
+ The gradient of the objective with respect to this parameter.
+ state: any obj
+ AssignmentOptimizer will not need to be associated with state.
+ """
+
+ weight[:] = grad
+
+
+@mx.optimizer.register
+class _SVRGOptimizer(mx.optimizer.Optimizer):
+ """_SVRGOptimizer is a wrapper class for two optimizers: _AssignmentOptimizer for accumulating full gradients in the
+ KVStore and a default optimizer that is passed in as a parameter in `mod.init_optimizer()`
+ The _SVRGOptimizer is designed to be used with SVRGModule only.
+
+ This optimizer accepts the following parameters in addition to those accepted by :class:`.Optimizer`.
+
+ Parameters
+ ----------
+ default_optimizer: str or Optimizer
+ Optimizer passed-in when invoke on mx.mod.init_optimizer in SVRGModule
+ """
+
+ def __init__(self, default_optimizer, **kwargs):
+ # Reconstruct kwargs to identify additional params for default optimizer
+ base_param = self._check_params(**kwargs)
+ super(_SVRGOptimizer, self).__init__(**base_param)
+ if isinstance(default_optimizer, str):
+ self.default_opt = mx.optimizer.create(default_optimizer, **kwargs)
+ else:
+ self.default_opt = default_optimizer
+ self.aux_opt = mx.optimizer.create(_AssignmentOptimizer.__name__)
+
+ @staticmethod
+ def _check_params(**kwargs):
+ """ Reassemble kwargs to identify additional optimizer params for default optimizers. base_params contains
+ all the param names in base class Optimizer.
+
+ Parameters
+ ----------
+ kwargs: dict
+ Parameters for the default optimizer
+
+ Returns
+ ----------
+ default_params: dict
+ Optimizer parameters that are defined in base class Optimizer
+ """
+
+ optimizer_param = dict(kwargs)
+ base_params = ['rescale_grad', 'param_idx2name', 'wd', 'clip_gradient', 'learning_rate', 'lr_scheduler', 'sym',
+ 'begin_num_update', 'multi_precision', 'param_dict']
+
+ default_params = {}
+ for key, _ in optimizer_param.items():
+ if key in base_params:
+ default_params[key] = optimizer_param[key]
+
+ return default_params
+
+ def update(self, index, weight, grad, state):
+ """Updates the given parameter using the corresponding gradient and state. If key contains 'full', update with
+ `_AssignmentOptimizer` otherwise will use default optimizer.
+
+ Parameters
+ ----------
+ index : int
+ The unique index of the parameter into the individual learning
+ rates and weight decays. Learning rates and weight decay
+ may be set via `set_lr_mult()` and `set_wd_mult()`, respectively.
+ weight : NDArray
+ The parameter to be updated.
+ grad : NDArray
+ The gradient of the objective with respect to this parameter.
+ state : any obj
+ The state returned by `create_state()`.
+ """
+
+ name = self._check_index(index)
+
+ if "full" in name:
+ self.aux_opt.update(index, weight, grad, state)
+ else:
+ # use the default optimizer
+ self.default_opt.update(index, weight, grad, state)
+
+ def create_state(self, index, weight):
+ """Creates auxiliary state for a given weight.
+ Some optimizers require additional states, e.g. as momentum, in addition
+ to gradients in order to update weights. This function creates state
+ for a given weight which will be used in `update`. This function is
+ called only once for each weight.
+
+ Parameters
+ ----------
+ index : int
+ An unique index to identify the weight.
+ weight : NDArray
+ The weight.
+ Returns
+ -------
+ state : any obj
+ The state associated with the weight.
+ """
+
+ name = self._check_index(index)
+ if "full" in name:
+ return self.aux_opt.create_state(index, weight)
+ else:
+ #
+ return self.default_opt.create_state(index, weight)
+
+ def _check_index(self, index):
+ """Check index in idx2name to get corresponding param_name
+ Parameters
+ ----------
+ index : int or str
+ An unique index to identify the weight.
+ Returns
+ -------
+ name : str
+ Name of the Module parameter
+ """
+
+ if index in self.idx2name.values():
+ # index is a str
+ name = index
+ else:
+ # index is an int
+ name = self.idx2name[index]
+ return name
diff --git a/tests/python/unittest/test_contrib_svrg_module.py b/tests/python/unittest/test_contrib_svrg_module.py
new file mode 100644
index 00000000000..d9e0abaebb2
--- /dev/null
+++ b/tests/python/unittest/test_contrib_svrg_module.py
@@ -0,0 +1,307 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 mxnet as mx
+import numpy as np
+from common import with_seed, assertRaises
+from mxnet.contrib.svrg_optimization.svrg_module import SVRGModule
+from mxnet.test_utils import *
+
+
+def setup():
+ train_data = np.random.randint(1, 5, [1000, 2])
+ weights = np.array([1.0, 2.0])
+ train_label = train_data.dot(weights)
+
+ di = mx.io.NDArrayIter(train_data, train_label, batch_size=32, shuffle=True, label_name='lin_reg_label')
+ X = mx.sym.Variable('data')
+ Y = mx.symbol.Variable('lin_reg_label')
+ fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1)
+ lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro")
+
+ mod = SVRGModule(
+ symbol=lro,
+ data_names=['data'],
+ label_names=['lin_reg_label'], update_freq=2)
+ mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)
+ mod.init_params(initializer=mx.init.Uniform(0.01), allow_missing=False, force_init=False, allow_extra=False)
+
+ return di, mod
+
+
+def test_bind_module():
+ _, mod = setup()
+ assert mod.binded == True
+ assert mod._mod_aux.binded == True
+
+
+def test_module_init():
+ _, mod = setup()
+ assert mod._mod_aux is not None
+
+
+def test_module_initializer():
+ def regression_model(m):
+ x = mx.symbol.var("data", stype='csr')
+ v = mx.symbol.var("v", shape=(m, 1), init=mx.init.Uniform(scale=.1),
+ stype='row_sparse')
+ model = mx.symbol.dot(lhs=x, rhs=v)
+ y = mx.symbol.Variable("label")
+ model = mx.symbol.LinearRegressionOutput(data=model, label=y, name="out")
+ return model
+
+ #shape of the data
+ n, m = 128, 100
+ model = regression_model(m)
+
+ data = mx.nd.zeros(shape=(n, m), stype='csr')
+ label = mx.nd.zeros((n, 1))
+ iterator = mx.io.NDArrayIter(data=data, label={'label': label},
+ batch_size=n, last_batch_handle='discard')
+
+ # create module
+ mod = SVRGModule(symbol=model, data_names=['data'], label_names=['label'], update_freq=2)
+ mod.bind(data_shapes=iterator.provide_data, label_shapes=iterator.provide_label)
+ mod.init_params()
+ v = mod._arg_params['v']
+ assert v.stype == 'row_sparse'
+ assert np.sum(v.asnumpy()) != 0
+
+
+def test_module_bind():
+ x = mx.sym.Variable("data")
+ net = mx.sym.FullyConnected(x, num_hidden=1)
+
+ mod = SVRGModule(symbol=net, data_names=['data'], label_names=None, update_freq=2)
+ assertRaises(TypeError, mod.bind, data_shapes=['data', mx.nd.zeros(shape=(2, 1))])
+
+ mod.bind(data_shapes=[('data', (2, 1))])
+ assert mod.binded == True
+ assert mod._mod_aux.binded == True
+
+
+@with_seed()
+def test_module_save_load():
+ import tempfile
+ import os
+
+ x = mx.sym.Variable("data")
+ y = mx.sym.Variable("softmax_label")
+ net = mx.sym.FullyConnected(x, y, num_hidden=1)
+
+ mod = SVRGModule(symbol=net, data_names=['data'], label_names=['softmax_label'], update_freq=2)
+ mod.bind(data_shapes=[('data', (1, 1))])
+ mod.init_params()
+ mod.init_optimizer(optimizer='sgd', optimizer_params={'learning_rate': 0.1})
+ mod.update()
+
+ # Create tempfile
+ tmp = tempfile.mkdtemp()
+ tmp_file = os.path.join(tmp, 'svrg_test_output')
+ mod.save_checkpoint(tmp_file, 0, save_optimizer_states=True)
+
+ mod2 = SVRGModule.load(tmp_file, 0, load_optimizer_states=True, data_names=('data', ))
+ mod2.bind(data_shapes=[('data', (1, 1))])
+ mod2.init_optimizer(optimizer_params={'learning_rate': 0.1})
+ assert mod._symbol.tojson() == mod2._symbol.tojson()
+
+ # Multi-device
+ mod3 = SVRGModule(symbol=net, data_names=['data'], label_names=['softmax_label'], update_freq=3,
+ context=[mx.cpu(0), mx.cpu(1)])
+ mod3.bind(data_shapes=[('data', (10, 10))])
+ mod3.init_params()
+ mod3.init_optimizer(optimizer_params={'learning_rate': 1.0})
+ mod3.update()
+ mod3.save_checkpoint(tmp_file, 0, save_optimizer_states=True)
+
+ mod4 = SVRGModule.load(tmp_file, 0, load_optimizer_states=True, data_names=('data', ))
+ mod4.bind(data_shapes=[('data', (10, 10))])
+ mod4.init_optimizer(optimizer_params={'learning_rate': 1.0})
+ assert mod3._symbol.tojson() == mod4._symbol.tojson()
+
+
+@with_seed()
+def test_svrgmodule_reshape():
+ data = mx.sym.Variable("data")
+ sym = mx.sym.FullyConnected(data=data, num_hidden=4, name='fc')
+
+ dshape=(3, 4)
+ mod = SVRGModule(sym, data_names=["data"], label_names=None, context=[mx.cpu(0), mx.cpu(1)], update_freq=2)
+ mod.bind(data_shapes=[('data', dshape)])
+ mod.init_params()
+ mod._mod_aux.init_params()
+ mod.init_optimizer(optimizer_params={"learning_rate": 1.0})
+
+ data_batch = mx.io.DataBatch(data=[mx.nd.ones(dshape)], label=None)
+ mod.forward(data_batch)
+ mod.backward([mx.nd.ones(dshape)])
+ mod.update()
+ assert mod.get_outputs()[0].shape == dshape
+
+ dshape = (2, 4)
+ mod.reshape(data_shapes=[('data', dshape)])
+ mod.forward(mx.io.DataBatch(data=[mx.nd.ones(dshape)],
+ label=None))
+ mod.backward([mx.nd.ones(dshape)])
+ mod.update()
+ assert mod.get_outputs()[0].shape == dshape
+
+
+@with_seed()
+def test_update_full_grad():
+ def create_network():
+ train_data = np.random.randint(1, 5, [10, 2])
+ weights = np.array([1.0, 2.0])
+ train_label = train_data.dot(weights)
+
+ di = mx.io.NDArrayIter(train_data, train_label, batch_size=5, shuffle=True, label_name='lin_reg_label')
+ X = mx.sym.Variable('data')
+ Y = mx.symbol.Variable('lin_reg_label')
+ fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1)
+ lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro")
+
+ mod = SVRGModule(
+ symbol=lro,
+ data_names=['data'],
+ label_names=['lin_reg_label'], update_freq=2)
+ mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)
+ mod.init_params(initializer=mx.init.One(), allow_missing=False, force_init=False, allow_extra=False)
+ mod.init_optimizer(kvstore='local', optimizer='sgd', optimizer_params=(('learning_rate', 0.01),),
+ force_init=False)
+ return di, mod
+
+ di, svrg_mod = create_network()
+
+ # Calculates the average of full gradients over number batches
+ full_grads_weights = mx.nd.zeros(shape=svrg_mod.get_params()[0]['fc1_weight'].shape)
+ arg, aux = svrg_mod.get_params()
+ svrg_mod._mod_aux.set_params(arg_params=arg, aux_params=aux)
+ num_batch = 2
+
+ for batch in di:
+ svrg_mod.forward(batch)
+ svrg_mod.backward()
+ full_grads_weights = mx.nd.broadcast_add(svrg_mod._exec_group.grad_arrays[0][0], full_grads_weights, axis=0)
+ full_grads_weights /= num_batch
+
+ di.reset()
+ svrg_mod.update_full_grads(di)
+ assert same(full_grads_weights, svrg_mod._param_dict[0]['fc1_weight'])
+
+
+@with_seed()
+def test_svrg_with_sgd():
+ def create_module_with_sgd():
+ train_data = np.random.randint(1, 5, [100, 2])
+ weights = np.array([1.0, 2.0])
+ train_label = train_data.dot(weights)
+
+ di = mx.io.NDArrayIter(train_data, train_label, batch_size=10, shuffle=True, label_name='lin_reg_label')
+ X = mx.sym.Variable('data')
+ Y = mx.symbol.Variable('lin_reg_label')
+ fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1)
+ lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro")
+
+ reg_mod = mx.mod.Module(
+ symbol=lro,
+ data_names=['data'],
+ label_names=['lin_reg_label'])
+ reg_mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)
+ reg_mod.init_params(initializer=mx.init.One(), allow_missing=False, force_init=False, allow_extra=False)
+ reg_mod.init_optimizer(kvstore='local', optimizer='sgd', optimizer_params=(('learning_rate', 0.01),))
+
+ svrg_mod = SVRGModule(symbol=lro,
+ data_names=['data'],
+ label_names=['lin_reg_label'],
+ update_freq=2)
+ svrg_mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)
+ svrg_mod.init_params(initializer=mx.init.One(), allow_missing=False, force_init=False, allow_extra=False)
+ svrg_mod.init_optimizer(kvstore='local', optimizer='sgd', optimizer_params=(('learning_rate', 0.01),))
+
+ return di,reg_mod, svrg_mod
+
+ di, reg_mod, svrg_mod = create_module_with_sgd()
+ num_epoch = 10
+
+ # Use metric MSE
+ metrics = mx.metric.create("mse")
+
+ # Train with SVRGModule
+ for e in range(num_epoch):
+ metrics.reset()
+ if e % svrg_mod.update_freq == 0:
+ svrg_mod.update_full_grads(di)
+ di.reset()
+ for batch in di:
+ svrg_mod.forward_backward(data_batch=batch)
+ svrg_mod.update()
+ svrg_mod.update_metric(metrics, batch.label)
+ svrg_mse = metrics.get()[1]
+
+ # Train with SGD standard Module
+ di.reset()
+ for e in range(num_epoch):
+ metrics.reset()
+ di.reset()
+ for batch in di:
+ reg_mod.forward_backward(data_batch=batch)
+ reg_mod.update()
+ reg_mod.update_metric(metrics, batch.label)
+ sgd_mse = metrics.get()[1]
+
+ assert svrg_mse < sgd_mse
+
+
+@with_seed()
+def test_accumulate_kvstore():
+ # Test KVStore behavior when push a list of values
+ kv = mx.kv.create('local')
+ kv.init("fc1_weight", mx.nd.zeros(shape=(1, 2)))
+ kv.init("fc1_weight_full", mx.nd.zeros(shape=(1, 2)))
+ b = [mx.nd.ones(shape=(1, 2)) for i in range(4)]
+ a = mx.nd.zeros(shape=(1, 2))
+ kv.push("fc1_weight_full", b)
+ kv.pull("fc1_weight_full", out=a)
+ assert same(a, [mx.nd.array([4, 4])])
+ assert kv.num_workers == 1
+
+ # Test accumulate in KVStore and allocate gradients
+ kv_test = mx.kv.create('local')
+ _, svrg_mod = setup()
+ svrg_mod.init_optimizer(kvstore=kv_test, optimizer='sgd', optimizer_params=(('learning_rate', 0.01),),
+ force_init=False)
+ svrg_mod._accumulate_kvstore("fc1_weight", b)
+ assert len(svrg_mod._param_dict) == svrg_mod._ctx_len
+ assert same(svrg_mod._param_dict[0]["fc1_weight"], b[0])
+
+
+@with_seed()
+def test_fit():
+ di, mod = setup()
+ num_epoch = 100
+ metric = mx.metric.create("mse")
+ mod.fit(di, eval_metric=metric, optimizer='sgd', optimizer_params=(('learning_rate', 0.025),), num_epoch=num_epoch,
+ kvstore='local')
+
+ # Estimated MSE for using SGD optimizer of lr = 0.025, SVRG MSE should be smaller
+ estimated_mse = 1e-5
+ assert metric.get()[1] < estimated_mse
+
+
+if __name__ == "__main__":
+ import nose
+ nose.runmodule()
diff --git a/tests/python/unittest/test_contrib_svrg_optimizer.py b/tests/python/unittest/test_contrib_svrg_optimizer.py
new file mode 100644
index 00000000000..f7d90d12872
--- /dev/null
+++ b/tests/python/unittest/test_contrib_svrg_optimizer.py
@@ -0,0 +1,101 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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 numpy as np
+import mxnet as mx
+from mxnet.test_utils import same
+from mxnet.contrib.svrg_optimization.svrg_module import SVRGModule
+from mxnet.contrib.svrg_optimization.svrg_optimizer import _SVRGOptimizer
+
+
+def create_network():
+
+ train_data = np.random.randint(1, 5, [1000, 2])
+ weights = np.array([1.0, 2.0])
+ train_label = train_data.dot(weights)
+
+ batch_size = 32
+
+ di = mx.io.NDArrayIter(train_data, train_label, batch_size=batch_size, shuffle=True, label_name='lin_reg_label')
+ X = mx.sym.Variable('data')
+ Y = mx.symbol.Variable('lin_reg_label')
+ fully_connected_layer = mx.sym.FullyConnected(data=X, name='fc1', num_hidden=1)
+ lro = mx.sym.LinearRegressionOutput(data=fully_connected_layer, label=Y, name="lro")
+
+ mod = SVRGModule(
+ symbol=lro,
+ data_names=['data'],
+ label_names=['lin_reg_label'], update_freq=2
+ )
+
+ mod.bind(data_shapes=di.provide_data, label_shapes=di.provide_label)
+ mod.init_params(initializer=mx.init.Uniform(0.01), allow_missing=False,
+ force_init=False, allow_extra=False)
+
+ return di, mod
+
+
+def test_init_svrg_optimizer():
+ _, mod = create_network()
+
+ kv = mx.kv.create('local')
+ mod.init_optimizer(kvstore=kv, optimizer='sgd', optimizer_params=(('learning_rate', 0.01),),
+ force_init=False)
+
+ assert type(mod._optimizer).__name__ == _SVRGOptimizer.__name__
+
+
+def test_svrg_optimizer_constructor():
+ kv = mx.kv.create('local')
+ svrg_optimizer = _SVRGOptimizer(default_optimizer='sgd', learning_rate=-1.0)
+ kv.set_optimizer(svrg_optimizer)
+
+ assert svrg_optimizer.default_opt.lr == -1.0
+
+
+def test_kvstore_init_aux_keys():
+ param_idx2name = {0: "weight", 1: "weight_full"}
+
+ svrg_optimizer = _SVRGOptimizer(default_optimizer='sgd', param_idx2name= param_idx2name, learning_rate=1.0)
+ kv = mx.kv.create('local')
+ kv.set_optimizer(svrg_optimizer)
+
+ # Use default sgd optimizer
+ param_weight_init = mx.nd.array([0, 0, 0])
+ param_weight_update = mx.nd.array([1, 1, 1])
+
+ kv.init(0, param_weight_init)
+ kv.push(0, param_weight_update)
+ kv.pull(0, param_weight_init)
+
+ param_weight_full_init = mx.nd.array([1, 1, 1])
+ param_weight_full_update = mx.nd.array([2, 2, 2])
+
+ # Use AssignmentOptimizer
+ kv.init(1, param_weight_full_init)
+ kv.push(1, param_weight_full_update)
+ kv.pull(1, param_weight_full_init)
+
+ # updated weights using default sgd optimizer
+ assert same(param_weight_init.asnumpy(), np.array([-1, -1, -1]))
+ # updated with AssignmentOptimizer
+ assert same(param_weight_full_init.asnumpy(), np.array([2, 2, 2]))
+
+
+if __name__ == "__main__":
+ import nose
+ nose.runmodule()
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services