+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ ![](\"http://webdocs.cs.ualberta.ca/~bx3/char-rnn_1.png\")
\n"
+ "![](\"http://data.dmlc.ml/mxnet/data/char-rnn_1.png\")
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "![](\"http://webdocs.cs.ualberta.ca/~bx3/char-rnn_2.png\")
"
+ "![](\"http://data.dmlc.ml/mxnet/data/char-rnn_2.png\")
"
]
},
{
@@ -145,7 +145,7 @@
],
"source": [
"import os\n",
- "data_url = \"http://webdocs.cs.ualberta.ca/~bx3/lab_data.zip\"\n",
+ "data_url = \"http://data.dmlc.ml/mxnet/data/lab_data.zip\"\n",
"os.system(\"wget %s\" % data_url)\n",
"os.system(\"unzip -o lab_data.zip\")"
]
diff --git a/example/svm_mnist/README.md b/example/svm_mnist/README.md
new file mode 100644
index 000000000000..082c2053f27e
--- /dev/null
+++ b/example/svm_mnist/README.md
@@ -0,0 +1,11 @@
+# Use case with Support Vector Machine
+
+To ensure that not only the implementation is learning, but is able to outsmart the softmax, as [this article](arxiv.org/pdf/1306.0239.pdf) suggests, I ran svm_mnist.py script. It was based on the MNIST experiment description on the article and [this tutorial](https://github.com/dmlc/mxnet-gtc-tutorial/blob/master/tutorial.ipynb).
+
+
+## To this you will need
+
+* [Numpy](http://www.scipy.org/scipylib/download.html)
+* [Sklearn](http://scikit-learn.org/stable/install.html)
+
+I recommend installing [matplot](http://matplotlib.org/users/installing.html) to visualize examples
\ No newline at end of file
diff --git a/example/svm_mnist/svm_mnist.py b/example/svm_mnist/svm_mnist.py
new file mode 100644
index 000000000000..f36a0457616f
--- /dev/null
+++ b/example/svm_mnist/svm_mnist.py
@@ -0,0 +1,84 @@
+
+#############################################################
+## Please read the README.md document for better reference ##
+#############################################################
+
+import mxnet as mx
+import numpy as np
+from sklearn.datasets import fetch_mldata
+from sklearn.decomposition import PCA
+# import matplotlib.pyplot as plt
+import logging
+
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)
+
+# Network declaration as symbols. The following pattern was based
+# on the article, but feel free to play with the number of nodes
+# and with the activation function
+data = mx.symbol.Variable('data')
+fc1 = mx.symbol.FullyConnected(data = data, name='fc1', num_hidden=512)
+act1 = mx.symbol.Activation(data = fc1, name='relu1', act_type="relu")
+fc2 = mx.symbol.FullyConnected(data = act1, name = 'fc2', num_hidden = 512)
+act2 = mx.symbol.Activation(data = fc2, name='relu2', act_type="relu")
+fc3 = mx.symbol.FullyConnected(data = act2, name='fc3', num_hidden=10)
+
+# Here we add the ultimate layer based on L2-SVM objective
+mlp = mx.symbol.SVMOutput(data=fc3, name='svm')
+
+# To use L1-SVM objective, comment the line above and uncomment the line below
+# mlp = mx.symbol.SVMOutput(data=fc3, name='svm', use_linear=True)
+
+# Now we fetch MNIST dataset, add some noise, as the article suggests,
+# permutate and assign the examples to be used on our network
+mnist = fetch_mldata('MNIST original')
+mnist_pca = PCA(n_components=70).fit_transform(mnist.data)
+noise = np.random.normal(size=mnist_pca.shape)
+mnist_pca += noise
+np.random.seed(1234) # set seed for deterministic ordering
+p = np.random.permutation(mnist_pca.shape[0])
+X = mnist_pca[p]
+Y = mnist.target[p]
+X_show = mnist.data[p]
+
+# This is just to normalize the input to a value inside [0,1],
+# and separate train set and test set
+X = X.astype(np.float32)/255
+X_train = X[:60000]
+X_test = X[60000:]
+X_show = X_show[60000:]
+Y_train = Y[:60000]
+Y_test = Y[60000:]
+
+# Article's suggestion on batch size
+batch_size = 200
+train_iter = mx.io.NDArrayIter(X_train, Y_train, batch_size=batch_size)
+test_iter = mx.io.NDArrayIter(X_test, Y_test, batch_size=batch_size)
+
+# A quick work around to prevent mxnet complaining the lack of a softmax_label
+train_iter.label = mx.io._init_data(Y_train, allow_empty=True, default_name='svm_label')
+test_iter.label = mx.io._init_data(Y_test, allow_empty=True, default_name='svm_label')
+
+# Here we instatiate and fit the model for our data
+# The article actually suggests using 400 epochs,
+# But I reduced to 10, for convinience
+model = mx.model.FeedForward(
+ ctx = mx.cpu(0), # Run on CPU 0
+ symbol = mlp, # Use the network we just defined
+ num_epoch = 10, # Train for 10 epochs
+ learning_rate = 0.1, # Learning rate
+ momentum = 0.9, # Momentum for SGD with momentum
+ wd = 0.00001, # Weight decay for regularization
+ )
+model.fit(
+ X=train_iter, # Training data set
+ eval_data=test_iter, # Testing data set. MXNet computes scores on test set every epoch
+ batch_end_callback = mx.callback.Speedometer(batch_size, 200)) # Logging module to print out progress
+
+# Uncomment to view an example
+# plt.imshow((X_show[0].reshape((28,28))*255).astype(np.uint8), cmap='Greys_r')
+# plt.show()
+# print 'Result:', model.predict(X_test[0:1])[0].argmax()
+
+# Now it prints how good did the network did for this configuration
+print 'Accuracy:', model.score(test_iter)*100, '%'
\ No newline at end of file
diff --git a/example/warpctc/README.md b/example/warpctc/README.md
new file mode 100644
index 000000000000..32306aa157bd
--- /dev/null
+++ b/example/warpctc/README.md
@@ -0,0 +1,91 @@
+# Baidu Warp CTC with Mxnet
+
+Baidu-warpctc is a CTC implement by Baidu which support GPU. CTC can be used with LSTM to solve lable alignment problems in many areas such as OCR, speech recognition.
+
+## Install baidu warpctc
+
+```
+ cd ~/
+ git clone https://github.com/baidu-research/warp-ctc
+ cd warp-ctc
+ mkdir build
+ cd build
+ cmake ..
+ make
+ sudo make install
+```
+
+## Enable warpctc in mxnet
+
+```
+ comment out following lines in make/config.mk
+ WARPCTC_PATH = $(HOME)/warp-ctc
+ MXNET_PLUGINS += plugin/warpctc/warpctc.mk
+
+ rebuild mxnet by
+ make clean && make -j4
+```
+
+## Run examples
+
+I implement two examples, one is just a toy example which can be used to prove ctc integration is right. The second is a OCR example with LSTM+CTC. You can run it by:
+
+```
+ cd examples/warpctc
+ python lstm_ocr.py
+```
+
+The OCR example is constructed as follows:
+
+1. I generate 80x30 image for 4 digits captcha by an python captcha library
+2. The 80x30 image is used as 80 input for lstm and every input is one column of image (a 30 dim vector)
+3. The output layer use CTC loss
+
+Following code show detail construction of the net:
+
+```
+ def lstm_unroll(num_lstm_layer, seq_len,
+ num_hidden, num_label):
+ param_cells = []
+ last_states = []
+ for i in range(num_lstm_layer):
+ param_cells.append(LSTMParam(i2h_weight=mx.sym.Variable("l%d_i2h_weight" % i),
+ i2h_bias=mx.sym.Variable("l%d_i2h_bias" % i),
+ h2h_weight=mx.sym.Variable("l%d_h2h_weight" % i),
+ h2h_bias=mx.sym.Variable("l%d_h2h_bias" % i)))
+ state = LSTMState(c=mx.sym.Variable("l%d_init_c" % i),
+ h=mx.sym.Variable("l%d_init_h" % i))
+ last_states.append(state)
+ assert(len(last_states) == num_lstm_layer)
+ data = mx.sym.Variable('data')
+ label = mx.sym.Variable('label')
+
+ #every column of image is an input, there are seq_len inputs
+ wordvec = mx.sym.SliceChannel(data=data, num_outputs=seq_len, squeeze_axis=1)
+ hidden_all = []
+ for seqidx in range(seq_len):
+ hidden = wordvec[seqidx]
+ for i in range(num_lstm_layer):
+ next_state = lstm(num_hidden, indata=hidden,
+ prev_state=last_states[i],
+ param=param_cells[i],
+ seqidx=seqidx, layeridx=i)
+ hidden = next_state.h
+ last_states[i] = next_state
+ hidden_all.append(hidden)
+ hidden_concat = mx.sym.Concat(*hidden_all, dim=0)
+ pred = mx.sym.FullyConnected(data=hidden_concat, num_hidden=11)
+
+ # here we do NOT need to transpose label as other lstm examples do
+ label = mx.sym.Reshape(data=label, target_shape=(0,))
+ #label should be int type, so use cast
+ label = mx.sym.Cast(data = label, dtype = 'int32')
+ sm = mx.sym.WarpCTC(data=pred, label=label, label_length = num_label, input_length = seq_len)
+ return sm
+```
+
+## Support multi label length
+
+If you label length is smalled than or equal to b. You should provide labels with length b, and for those samples which label length is smaller than b, you should append 0 to label data to make it have length b.
+
+Here, 0 is reserved for blank label.
diff --git a/example/warpctc/lstm.py b/example/warpctc/lstm.py
new file mode 100644
index 000000000000..32ba2455e11d
--- /dev/null
+++ b/example/warpctc/lstm.py
@@ -0,0 +1,79 @@
+# pylint:skip-file
+import sys
+sys.path.insert(0, "../../python")
+import mxnet as mx
+import numpy as np
+from collections import namedtuple
+import time
+import math
+LSTMState = namedtuple("LSTMState", ["c", "h"])
+LSTMParam = namedtuple("LSTMParam", ["i2h_weight", "i2h_bias",
+ "h2h_weight", "h2h_bias"])
+LSTMModel = namedtuple("LSTMModel", ["rnn_exec", "symbol",
+ "init_states", "last_states",
+ "seq_data", "seq_labels", "seq_outputs",
+ "param_blocks"])
+
+def lstm(num_hidden, indata, prev_state, param, seqidx, layeridx):
+ """LSTM Cell symbol"""
+ i2h = mx.sym.FullyConnected(data=indata,
+ weight=param.i2h_weight,
+ bias=param.i2h_bias,
+ num_hidden=num_hidden * 4,
+ name="t%d_l%d_i2h" % (seqidx, layeridx))
+ h2h = mx.sym.FullyConnected(data=prev_state.h,
+ weight=param.h2h_weight,
+ bias=param.h2h_bias,
+ num_hidden=num_hidden * 4,
+ name="t%d_l%d_h2h" % (seqidx, layeridx))
+ gates = i2h + h2h
+ slice_gates = mx.sym.SliceChannel(gates, num_outputs=4,
+ name="t%d_l%d_slice" % (seqidx, layeridx))
+ in_gate = mx.sym.Activation(slice_gates[0], act_type="sigmoid")
+ in_transform = mx.sym.Activation(slice_gates[1], act_type="tanh")
+ forget_gate = mx.sym.Activation(slice_gates[2], act_type="sigmoid")
+ out_gate = mx.sym.Activation(slice_gates[3], act_type="sigmoid")
+ next_c = (forget_gate * prev_state.c) + (in_gate * in_transform)
+ next_h = out_gate * mx.sym.Activation(next_c, act_type="tanh")
+ return LSTMState(c=next_c, h=next_h)
+
+
+def lstm_unroll(num_lstm_layer, seq_len,
+ num_hidden, num_label):
+ param_cells = []
+ last_states = []
+ for i in range(num_lstm_layer):
+ param_cells.append(LSTMParam(i2h_weight=mx.sym.Variable("l%d_i2h_weight" % i),
+ i2h_bias=mx.sym.Variable("l%d_i2h_bias" % i),
+ h2h_weight=mx.sym.Variable("l%d_h2h_weight" % i),
+ h2h_bias=mx.sym.Variable("l%d_h2h_bias" % i)))
+ state = LSTMState(c=mx.sym.Variable("l%d_init_c" % i),
+ h=mx.sym.Variable("l%d_init_h" % i))
+ last_states.append(state)
+ assert(len(last_states) == num_lstm_layer)
+
+ # embeding layer
+ data = mx.sym.Variable('data')
+ label = mx.sym.Variable('label')
+ wordvec = mx.sym.SliceChannel(data=data, num_outputs=seq_len, squeeze_axis=1)
+
+ hidden_all = []
+ for seqidx in range(seq_len):
+ hidden = wordvec[seqidx]
+ for i in range(num_lstm_layer):
+ next_state = lstm(num_hidden, indata=hidden,
+ prev_state=last_states[i],
+ param=param_cells[i],
+ seqidx=seqidx, layeridx=i)
+ hidden = next_state.h
+ last_states[i] = next_state
+ hidden_all.append(hidden)
+
+ hidden_concat = mx.sym.Concat(*hidden_all, dim=0)
+ pred = mx.sym.FullyConnected(data=hidden_concat, num_hidden=11)
+
+ label = mx.sym.Reshape(data=label, shape=(-1,))
+ label = mx.sym.Cast(data = label, dtype = 'int32')
+ sm = mx.sym.WarpCTC(data=pred, label=label, label_length = num_label, input_length = seq_len)
+ return sm
+
diff --git a/example/warpctc/lstm_ocr.py b/example/warpctc/lstm_ocr.py
new file mode 100644
index 000000000000..048572500b85
--- /dev/null
+++ b/example/warpctc/lstm_ocr.py
@@ -0,0 +1,176 @@
+# pylint: disable=C0111,too-many-arguments,too-many-instance-attributes,too-many-locals,redefined-outer-name,fixme
+# pylint: disable=superfluous-parens, no-member, invalid-name
+import sys, random
+sys.path.insert(0, "../../python")
+import numpy as np
+import mxnet as mx
+
+from lstm import lstm_unroll
+
+from io import BytesIO
+from captcha.image import ImageCaptcha
+import cv2, random
+
+class SimpleBatch(object):
+ def __init__(self, data_names, data, label_names, label):
+ self.data = data
+ self.label = label
+ self.data_names = data_names
+ self.label_names = label_names
+
+ self.pad = 0
+ self.index = None # TODO: what is index?
+
+ @property
+ def provide_data(self):
+ return [(n, x.shape) for n, x in zip(self.data_names, self.data)]
+
+ @property
+ def provide_label(self):
+ return [(n, x.shape) for n, x in zip(self.label_names, self.label)]
+
+def gen_rand():
+ buf = ""
+ max_len = random.randint(3,4)
+ for i in range(max_len):
+ buf += str(random.randint(0,9))
+ return buf
+
+def get_label(buf):
+ ret = np.zeros(4)
+ for i in range(len(buf)):
+ ret[i] = 1 + int(buf[i])
+ if len(buf) == 3:
+ ret[3] = 0
+ return ret
+
+class OCRIter(mx.io.DataIter):
+ def __init__(self, count, batch_size, num_label, init_states):
+ super(OCRIter, self).__init__()
+ self.captcha = ImageCaptcha(fonts=['./data/Xerox.ttf'])
+ self.batch_size = batch_size
+ self.count = count
+ self.num_label = num_label
+ self.init_states = init_states
+ self.init_state_arrays = [mx.nd.zeros(x[1]) for x in init_states]
+ self.provide_data = [('data', (batch_size, 2400))] + init_states
+ self.provide_label = [('label', (self.batch_size, 4))]
+
+ def __iter__(self):
+ print 'iter'
+ init_state_names = [x[0] for x in self.init_states]
+ for k in range(self.count):
+ data = []
+ label = []
+ for i in range(self.batch_size):
+ num = gen_rand()
+ img = self.captcha.generate(num)
+ img = np.fromstring(img.getvalue(), dtype='uint8')
+ img = cv2.imdecode(img, cv2.IMREAD_GRAYSCALE)
+ img = cv2.resize(img, (80, 30))
+ img = img.transpose(1, 0)
+ img = img.reshape((80 * 30))
+ img = np.multiply(img, 1/255.0)
+ data.append(img)
+ label.append(get_label(num))
+
+ data_all = [mx.nd.array(data)] + self.init_state_arrays
+ label_all = [mx.nd.array(label)]
+ data_names = ['data'] + init_state_names
+ label_names = ['label']
+
+
+ data_batch = SimpleBatch(data_names, data_all, label_names, label_all)
+ yield data_batch
+
+ def reset(self):
+ pass
+
+BATCH_SIZE = 32
+SEQ_LENGTH = 80
+
+def ctc_label(p):
+ ret = []
+ p1 = [0] + p
+ for i in range(len(p)):
+ c1 = p1[i]
+ c2 = p1[i+1]
+ if c2 == 0 or c2 == c1:
+ continue
+ ret.append(c2)
+ return ret
+
+def remove_blank(l):
+ ret = []
+ for i in range(len(l)):
+ if l[i] == 0:
+ break
+ ret.append(l[i])
+ return ret
+
+def Accuracy(label, pred):
+ global BATCH_SIZE
+ global SEQ_LENGTH
+ hit = 0.
+ total = 0.
+ for i in range(BATCH_SIZE):
+ l = remove_blank(label[i])
+ p = []
+ for k in range(SEQ_LENGTH):
+ p.append(np.argmax(pred[k * BATCH_SIZE + i]))
+ p = ctc_label(p)
+ if len(p) == len(l):
+ match = True
+ for k in range(len(p)):
+ if p[k] != int(l[k]):
+ match = False
+ break
+ if match:
+ hit += 1.0
+ total += 1.0
+ return hit / total
+
+if __name__ == '__main__':
+ num_hidden = 100
+ num_lstm_layer = 2
+
+ num_epoch = 10
+ learning_rate = 0.001
+ momentum = 0.9
+ num_label = 4
+
+ contexts = [mx.context.gpu(1)]
+
+ def sym_gen(seq_len):
+ return lstm_unroll(num_lstm_layer, seq_len,
+ num_hidden=num_hidden,
+ num_label = num_label)
+
+ init_c = [('l%d_init_c'%l, (BATCH_SIZE, num_hidden)) for l in range(num_lstm_layer)]
+ init_h = [('l%d_init_h'%l, (BATCH_SIZE, num_hidden)) for l in range(num_lstm_layer)]
+ init_states = init_c + init_h
+
+ data_train = OCRIter(10000, BATCH_SIZE, num_label, init_states)
+ data_val = OCRIter(1000, BATCH_SIZE, num_label, init_states)
+
+ symbol = sym_gen(SEQ_LENGTH)
+
+ model = mx.model.FeedForward(ctx=contexts,
+ symbol=symbol,
+ num_epoch=num_epoch,
+ learning_rate=learning_rate,
+ momentum=momentum,
+ wd=0.00001,
+ initializer=mx.init.Xavier(factor_type="in", magnitude=2.34))
+
+ import logging
+ head = '%(asctime)-15s %(message)s'
+ logging.basicConfig(level=logging.DEBUG, format=head)
+
+ print 'begin fit'
+
+ model.fit(X=data_train, eval_data=data_val,
+ eval_metric = mx.metric.np(Accuracy),
+ batch_end_callback=mx.callback.Speedometer(BATCH_SIZE, 50),)
+
+ model.save("ocr")
diff --git a/example/warpctc/toy_ctc.py b/example/warpctc/toy_ctc.py
new file mode 100644
index 000000000000..2caa11e68399
--- /dev/null
+++ b/example/warpctc/toy_ctc.py
@@ -0,0 +1,163 @@
+# pylint: disable=C0111,too-many-arguments,too-many-instance-attributes,too-many-locals,redefined-outer-name,fixme
+# pylint: disable=superfluous-parens, no-member, invalid-name
+import sys
+sys.path.insert(0, "../../python")
+import numpy as np
+import mxnet as mx
+import random
+from lstm import lstm_unroll
+
+class SimpleBatch(object):
+ def __init__(self, data_names, data, label_names, label):
+ self.data = data
+ self.label = label
+ self.data_names = data_names
+ self.label_names = label_names
+
+ self.pad = 0
+ self.index = None # TODO: what is index?
+
+ @property
+ def provide_data(self):
+ return [(n, x.shape) for n, x in zip(self.data_names, self.data)]
+
+ @property
+ def provide_label(self):
+ return [(n, x.shape) for n, x in zip(self.label_names, self.label)]
+
+def gen_feature(n):
+ ret = np.zeros(10)
+ ret[n] = 1
+ return ret
+
+def gen_rand():
+ num = random.randint(0, 9999)
+ buf = str(num)
+ while len(buf) < 4:
+ buf = "0" + buf
+ ret = np.array([])
+ for i in range(80):
+ c = int(buf[i / 20])
+ ret = np.concatenate([ret, gen_feature(c)])
+ return buf, ret
+
+def get_label(buf):
+ ret = np.zeros(4)
+ for i in range(4):
+ ret[i] = 1 + int(buf[i])
+ return ret
+
+class DataIter(mx.io.DataIter):
+ def __init__(self, count, batch_size, num_label, init_states):
+ super(DataIter, self).__init__()
+ self.batch_size = batch_size
+ self.count = count
+ self.num_label = num_label
+ self.init_states = init_states
+ self.init_state_arrays = [mx.nd.zeros(x[1]) for x in init_states]
+ self.provide_data = [('data', (batch_size, 10 * 80))] + init_states
+ self.provide_label = [('label', (self.batch_size, 4))]
+
+ def __iter__(self):
+ init_state_names = [x[0] for x in self.init_states]
+ for k in range(self.count):
+ data = []
+ label = []
+ for i in range(self.batch_size):
+ num, img = gen_rand()
+ data.append(img)
+ label.append(get_label(num))
+
+ data_all = [mx.nd.array(data)] + self.init_state_arrays
+ label_all = [mx.nd.array(label)]
+ data_names = ['data'] + init_state_names
+ label_names = ['label']
+
+
+ data_batch = SimpleBatch(data_names, data_all, label_names, label_all)
+ yield data_batch
+
+ def reset(self):
+ pass
+
+BATCH_SIZE = 32
+SEQ_LENGTH = 80
+
+def ctc_label(p):
+ ret = []
+ p1 = [0] + p
+ for i in range(len(p)):
+ c1 = p1[i]
+ c2 = p1[i+1]
+ if c2 == 0 or c2 == c1:
+ continue
+ ret.append(c2)
+ return ret
+
+
+def Accuracy(label, pred):
+ global BATCH_SIZE
+ global SEQ_LENGTH
+ hit = 0.
+ total = 0.
+ for i in range(BATCH_SIZE):
+ l = label[i]
+ p = []
+ for k in range(SEQ_LENGTH):
+ p.append(np.argmax(pred[k * BATCH_SIZE + i]))
+ p = ctc_label(p)
+ if len(p) == len(l):
+ match = True
+ for k in range(len(p)):
+ if p[k] != int(l[k]):
+ match = False
+ break
+ if match:
+ hit += 1.0
+ total += 1.0
+ return hit / total
+
+if __name__ == '__main__':
+ num_hidden = 100
+ num_lstm_layer = 1
+
+ num_epoch = 10
+ learning_rate = 0.001
+ momentum = 0.9
+ num_label = 4
+
+ contexts = [mx.context.gpu(0)]
+
+ def sym_gen(seq_len):
+ return lstm_unroll(num_lstm_layer, seq_len,
+ num_hidden=num_hidden,
+ num_label = num_label)
+
+ init_c = [('l%d_init_c'%l, (BATCH_SIZE, num_hidden)) for l in range(num_lstm_layer)]
+ init_h = [('l%d_init_h'%l, (BATCH_SIZE, num_hidden)) for l in range(num_lstm_layer)]
+ init_states = init_c + init_h
+
+ data_train = DataIter(100000, BATCH_SIZE, num_label, init_states)
+ data_val = DataIter(1000, BATCH_SIZE, num_label, init_states)
+
+ symbol = sym_gen(SEQ_LENGTH)
+
+ model = mx.model.FeedForward(ctx=contexts,
+ symbol=symbol,
+ num_epoch=num_epoch,
+ learning_rate=learning_rate,
+ momentum=momentum,
+ wd=0.00001,
+ initializer=mx.init.Xavier(factor_type="in", magnitude=2.34))
+
+ import logging
+ head = '%(asctime)-15s %(message)s'
+ logging.basicConfig(level=logging.DEBUG, format=head)
+
+ print 'begin fit'
+
+ model.fit(X=data_train, eval_data=data_val,
+ eval_metric = mx.metric.np(Accuracy),
+ batch_end_callback=mx.callback.Speedometer(BATCH_SIZE, 50),)
+
+ model.save("ocr")
diff --git a/include/mxnet/c_api.h b/include/mxnet/c_api.h
index 097e3eb603bd..28bc89406c0b 100644
--- a/include/mxnet/c_api.h
+++ b/include/mxnet/c_api.h
@@ -479,6 +479,14 @@ MXNET_DLL int MXFuncInvokeEx(FunctionHandle fun,
*/
MXNET_DLL int MXSymbolListAtomicSymbolCreators(mx_uint *out_size,
AtomicSymbolCreator **out_array);
+
+/*!
+ * \brief Get the name of an atomic symbol.
+ * \param creator the AtomicSymbolCreator.
+ * \param name The returned name of the creator.
+ */
+MXNET_DLL int MXSymbolGetAtomicSymbolName(AtomicSymbolCreator creator,
+ const char **name);
/*!
* \brief Get the detailed information about atomic symbol.
* \param creator the AtomicSymbolCreator.
diff --git a/include/mxnet/mxrtc.h b/include/mxnet/mxrtc.h
index a45badb1d3dc..9de59f63da2a 100644
--- a/include/mxnet/mxrtc.h
+++ b/include/mxnet/mxrtc.h
@@ -60,7 +60,7 @@ class MXRtc {
unsigned int block_dim_Z);
private:
- static const std::string str_type;
+ static const char str_type[];
static std::unordered_map