Backward computation.
`out-grads`: collection of NDArrays
    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.

Bind the symbols to construct executors. This is necessary before one
can perform computation with the module.
 `mod`: module
 `opts-map` {
   `data-shapes`: map of `:name`, `:shape`, `:dtype`, and `:layout`
       Typically is `(provide-data-desc data-iter)`.Data shape must be in the
       form of `io/data-desc`
   `label-shapes`: map of `:name` `:shape` `:dtype` and `:layout`
       Typically is `(provide-label-desc data-iter)`.
   `for-training`: boolean - Default is `true`
       Whether the executors should be bind for training.
   `inputs-need-grad`: boolean - 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`: boolean - Default is `false`.
       This function does nothing if the executors are already binded. But
       with this `true`, the executors will be forced to rebind.
   `shared-module`: Default is nil.
       This is used in bucketing. When not `nil`, 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).
 }
Ex:
  (bind {:data-shapes (mx-io/provide-data train-iter)
         :label-shapes (mx-io/provide-label test-iter)})) 

Borrow optimizer from a shared module. Used in bucketing, where exactly the
same optimizer (esp. kvstore) is used.
 `mod`: Module
 `shared-module`

Train the module parameters.
 `mod`: Module
 `opts-map` {
   `train-data`: DataIter
   `eval-data`: DataIter
       If not nil, will be used as validation set and evaluate the
       performance after each epoch.
   `num-epoch`: int
       Number of epochs to run training.
   `fit-params`: FitParams
       Extra parameters for training (see fit-params).
 }
Ex:
  (fit {:train-data train-iter :eval-data test-iter :num-epoch 100)
  (fit {:train-data train-iter
        :eval-data test-iter
        :num-epoch 5
        :fit-params
        (fit-params {:batch-end-callback (callback/speedometer 128 100)
                     :initializer (initializer/xavier)
                     :optimizer (optimizer/sgd {:learning-rate 0.01})
                     :eval-metric (eval-metric/mse)}))

Initialize FitParams with provided parameters.
  `eval-metric`: EvalMetric - Default is `accuracy`
  `kvstore`: String - Default is "local"
  `optimizer`: Optimizer - Default is `sgd`
  `initializer`: Initializer - Default is `uniform`
      Called to initialize parameters if needed.
  `arg-params`: map
      If not nil, should be a map of existing `arg-params`. Initialization
      will be copied from that.
  `aux-params`: map -
      If not nil, should be a map of existing `aux-params`. Initialization
      will be copied from that.
  `allow-missing`: boolean - Default is `false`
      If `true`, params could contain missing values, and the initializer will
      be called to fill those missing params.
  `force-rebind`: boolean - Default is `false`
      This function does nothing if the executors are already binded. But with
      this `true`, the executors will be forced to rebind.
  `force-init`: boolean - Default is `false`
      If `true`, will force re-initialize even if already initialized.
  `begin-epoch`: int - Default is 0
  `validation-metric`: EvalMetric
  `monitor`: Monitor
Ex:
  (fit-params {:force-init true :force-rebind true :allow-missing true})
  (fit-params
    {:batch-end-callback (callback/speedometer batch-size 100)
     :initializer (initializer/xavier)
     :optimizer (optimizer/sgd {:learning-rate 0.01})
     :eval-metric (eval-metric/mse)})

Forward computation.
`data-batch`: Either map or DataBatch
   Input data of form `io/data-batch`.
`is-train`: Default is nil
   Which means `is_train` takes the value of `for_training`.

A convenient function that calls both `forward` and `backward`.

Install and initialize optimizers.
 `mod`: Module
 `opts-map` {
   `kvstore`: string - Default is "local"
   `optimizer`: Optimizer - Default is `sgd`
   `reset-optimizer`: boolean - Default is `true`
       Indicating whether we should set `rescaleGrad` & `idx2name` for
       optimizer according to executorGroup.
   `force-init`: boolean - Default is `false`
       Indicating whether we should force re-initializing the optimizer
       in the case an optimizer is already installed.
Ex:
  (init-optimizer {:optimizer (optimizer/sgd {:learning-rate 0.1})})

Initialize the parameters and auxiliary states.
 `opts-map` {
   `initializer`: Initializer - Default is `uniform`
       Called to initialize parameters if needed.
   `arg-params`: map
       If not nil, should be a map of existing arg-params. Initialization
       will be copied from that.
   `aux-params`: map
       If not nil, should be a map of existing aux-params. Initialization
       will be copied from that.
   `allow-missing`: boolean - Default is `false`
       If true, params could contain missing values, and the initializer will
       be called to fill those missing params.
   `force-init` boolean - Default is `false`
       If true, will force re-initialize even if already initialized.
   `allow-extra`: boolean - Default is `false`
       Whether allow extra parameters that are not needed by symbol.
       If this is `true`, no error will be thrown when `arg-params` or
       `aux-params` contain extra parameters that is not needed by the
       executor.
Ex:
  (init-params {:initializer (initializer/xavier)})
  (init-params {:force-init true :allow-extra true})

Get the gradients to the inputs, computed in the previous backward computation.
In the case when data-parallelism is used, the outputs will be collected from
multiple devices. The results will look like
`[[grad1_dev1, grad1_dev2], [grad2_dev1, grad2_dev2]]`.
Those `NDArray`s might live on different devices.

Get the gradients to the inputs, computed in the previous backward computation.
In the case when data-parallelism is used, the outputs will be merged from
multiple devices, as they look like from a single executor.
The results will look like `[grad1, grad2]`.

Install monitor on all executors.

Create a model from previously saved checkpoint.
 `opts-map` {
   `prefix`: string
       Path prefix of saved model files. You should have prefix-symbol.json,
       prefix-xxxx.params, and optionally prefix-xxxx.states, where xxxx is
       the epoch number.
   `epoch`: int
       Epoch to load.
   `load-optimizer-states`: boolean - Default is false
        Whether to load optimizer states. Checkpoint needs to have been made
        with `save-optimizer-states` = `true`.
    `data-names`: vector of strings - Default is ["data"]
        Input data names.
    `label-names`: vector of strings - Default is ["softmax_label"]
        Input label names.
    `contexts`: Context - Default is `context/cpu`
    `workload-list`:  Default nil
        Indicating uniform workload.
    `fixed-param-names`: Default nil
        Indicating no network parameters are fixed.
Ex:
  (load-checkpoint {:prefix "my-model" :epoch 1 :load-optimizer-states true}

Load optimizer (updater) state from file.
`mod`: Module
`fname`: string - Path to input states file.

Module is a basic module that wrap a `symbol`.
 `sym`: Symbol definition.
 `opts-map` {
   `data-names`: vector of strings - Default is ["data"]
       Input data names
   `label-names`: vector of strings - Default is ["softmax_label"]
       Input label names
   `contexts`: Context - Default is `context/cpu`.
   `workload-list`: Default nil
       Indicating uniform workload.
   `fixed-param-names`: Default nil
       Indicating no network parameters are fixed.
 }
Ex:
  (module sym)
  (module sym {:data-names ["data"]
               :label-names ["linear_regression_label"]}

Get outputs of the previous forward computation.
In the case when data-parallelism is used, the outputs will be collected from
multiple devices. The results will look like
`[[out1_dev1, out1_dev2], [out2_dev1, out2_dev2]]`.
Those `NDArray`s might live on different devices.

Get outputs of the previous forward computation.
In the case when data-parallelism is used, the outputs will be merged from
multiple devices, as they look like from a single executor.
The results will look like `[out1, out2]`.

Run prediction and collect the outputs.
  `mod`: Module
  `opts-map` {
    `eval-data`: DataIter
    `num-batch` int - Default is `-1`
        Indicating running all the batches in the data iterator.
    `reset`: boolean - Default is `true`
        Indicating whether we should reset the data iter before start doing
        prediction.
  }
  returns: vector of NDArrays `[out1, out2, out3]` where each element is the
     concatenation of the outputs for all the mini-batches.
Ex:
  (predict mod {:eval-data test-iter})
  (predict mod {:eval-data test-iter :num-batch 10 :reset false})

Run the predication on a data batch.
`mod`: Module
`data-batch`: data-batch

Run prediction and collect the outputs.
 `mod`: Module
 `opts-map` {
   `eval-data`: DataIter
   `num-batch` int - Default is `-1`
       Indicating running all the batches in the data iterator.
   `reset` boolean - Default is `true`
       Indicating whether we should reset the data iter before start doing
       prediction.
 }
 returns: nested list like this
 `[[out1_batch1, out2_batch1, ...], [out1_batch2, out2_batch2, ...]]`

Note: This mode is useful because in some cases (e.g. bucketing), the module
      does not necessarily produce the same number of outputs.
Ex:
  (predict-every-batch mod {:eval-data test-iter})

Reshapes the module for new input shapes.
`mod`: Module
`data-shapes`: Typically is `(provide-data data-iter)`
`label-shapes`: Typically is `(provide-label data-tier)`

Save current progress to checkpoint.
Use mx.callback.module_checkpoint as epoch_end_callback to save during
training.
 `mod`: Module
 `opts-map` {
    `prefix`: string
        The file prefix to checkpoint to
    `epoch`: int
        The current epoch number
    `save-opt-states`: boolean - Default is `false`
        Whether to save optimizer states for continue training
 }
Ex:
  (save-checkpoint {:prefix "saved_model" :epoch 0 :save-opt-states true})

Save optimizer (updater) state to file.
`mod`: Module
`fname`: string - Path to output states file.

Run prediction on `eval-data` and evaluate the performance according to
`eval-metric`.
  `mod`: module
   `opts-map` {
     `eval-data`: DataIter
     `eval-metric`: EvalMetric
     `num-batch`: int - Default is `Integer.MAX_VALUE`
         Number of batches to run. Indicating run until the `DataIter`
         finishes.
     `batch-end-callback`: not supported yet.
     `reset`: boolean - Default is `true`,
         Indicating whether we should reset `eval-data` before starting
         evaluating.
     `epoch`: int - Default is 0
         For compatibility, this will be passed to callbacks (if any). During
         training, this will correspond to the training epoch number.
   }
 Ex:
   (score mod {:eval-data data-iter :eval-metric (eval-metric/accuracy)})
   (score mod {:eval-data data-iter
               :eval-metric (eval-metric/mse) :num-batch 10})

Assign parameters and aux state values.
 `mod`: Module
 `opts-map` {
   `arg-params`: map - map of name to value (`NDArray`) mapping.
   `aux-params`: map - map of name to value (`NDArray`) mapping.
   `allow-missing`: boolean
       If true, params could contain missing values, and the initializer will
       be called to fill those missing params.
   `force-init`: boolean - Default is `false`
       If true, will force re-initialize even if already initialized.
   `allow-extra`: boolean - Default is `false`
       Whether allow extra parameters that are not needed by symbol. If this
       is `true`, no error will be thrown when arg-params or aux-params
       contain extra parameters that is not needed by the executor.
 }
Ex:
  (set-params mod
    {:arg-params {"fc_0_weight" (ndarray/array [0.15 0.2 0.25 0.3] [2 2])
     :allow-missing true})

Update parameters according to the installed optimizer and the gradients
computed in the previous forward-backward batch.

Evaluate and accumulate evaluation metric on outputs of the last forward
 computation.
   `mod`: module
   `eval-metric`: EvalMetric
   `labels`: collection of NDArrays
Ex:
  (update-metric mod (eval-metric/mse) labels)