remove numpy changes to gluon peripherals

python/mxnet/gluon/data/dataloader.py

@@ -38,8 +38,6 @@
 
 from . import sampler as _sampler
 from ... import nd, context
-from ...util import is_np_shape, is_np_array, set_np
-from ... import numpy as _mx_np # pylint: disable=reimported
 
 if sys.platform == 'darwin' or sys.platform == 'win32':
  def rebuild_ndarray(*args):
@@ -131,33 +129,27 @@ def __init__(self, *args, **kwargs):
 def default_batchify_fn(data):
  """Collate data into batch."""
  if isinstance(data[0], nd.NDArray):
- return _mx_np.stack(data) if is_np_array() else nd.stack(*data)
+ return nd.stack(*data)
  elif isinstance(data[0], tuple):
  data = zip(*data)
  return [default_batchify_fn(i) for i in data]
  else:
  data = np.asarray(data)
- array_fn = _mx_np.array if is_np_array() else nd.array
- return array_fn(data, dtype=data.dtype)
+ return nd.array(data, dtype=data.dtype)
 
 
 def default_mp_batchify_fn(data):
  """Collate data into batch. Use shared memory for stacking."""
  if isinstance(data[0], nd.NDArray):
- empty_fn = _mx_np.empty if is_np_array() else nd.empty
- out = empty_fn((len(data),) + data[0].shape, dtype=data[0].dtype,
+ out = nd.empty((len(data),) + data[0].shape, dtype=data[0].dtype,
  ctx=context.Context('cpu_shared', 0))
- if is_np_array():
- return _mx_np.stack(data, out=out)
- else:
- return nd.stack(*data, out=out)
+ return nd.stack(*data, out=out)
  elif isinstance(data[0], tuple):
  data = zip(*data)
  return [default_mp_batchify_fn(i) for i in data]
  else:
  data = np.asarray(data)
- array_fn = _mx_np.array if is_np_array() else nd.array
- return array_fn(data, dtype=data.dtype,
+ return nd.array(data, dtype=data.dtype,
  ctx=context.Context('cpu_shared', 0))
 
 
@@ -393,20 +385,14 @@ def __len__(self):
  return len(self._batch_sampler)
 
 
-def _thread_worker_initializer(active_shape, active_array):
- """Initializer for ThreadPool."""
- set_np(shape=active_shape, array=active_array)
-
-
 _worker_dataset = None
-def _worker_initializer(dataset, active_shape, active_array):
+def _worker_initializer(dataset):
  """Initialier for processing pool."""
  # global dataset is per-process based and only available in worker processes
  # this is only necessary to handle MXIndexedRecordIO because otherwise dataset
  # can be passed as argument
  global _worker_dataset
  _worker_dataset = dataset
- set_np(shape=active_shape, array=active_array)
 
 def _worker_fn(samples, batchify_fn, dataset=None):
  """Function for processing data in worker process."""
@@ -573,13 +559,10 @@ def __init__(self, dataset, batch_size=None, shuffle=False, sampler=None,
  self._prefetch = max(0, int(prefetch) if prefetch is not None else 2 * self._num_workers)
  if self._num_workers > 0:
  if self._thread_pool:
- self._worker_pool = ThreadPool(self._num_workers,
- initializer=_thread_worker_initializer,
- initargs=(is_np_shape(), is_np_array()))
+ self._worker_pool = ThreadPool(self._num_workers)
  else:
  self._worker_pool = multiprocessing.Pool(
- self._num_workers, initializer=_worker_initializer,
- initargs=[self._dataset, is_np_shape(), is_np_array()])
+ self._num_workers, initializer=_worker_initializer, initargs=[self._dataset])
  if batchify_fn is None:
  if num_workers > 0:
  self._batchify_fn = default_mp_batchify_fn

python/mxnet/gluon/data/vision/datasets.py

@@ -31,8 +31,6 @@
 from .. import dataset
 from ...utils import download, check_sha1, _get_repo_file_url
 from .... import nd, image, recordio, base
-from .... import numpy as _mx_np # pylint: disable=reimported
-from ....util import is_np_array
 
 
 class MNIST(dataset._DownloadedDataset):
@@ -83,16 +81,13 @@ def _get_data(self):
  with gzip.open(label_file, 'rb') as fin:
  struct.unpack(">II", fin.read(8))
  label = np.frombuffer(fin.read(), dtype=np.uint8).astype(np.int32)
- if is_np_array():
- label = _mx_np.array(label, dtype=label.dtype)
 
  with gzip.open(data_file, 'rb') as fin:
  struct.unpack(">IIII", fin.read(16))
  data = np.frombuffer(fin.read(), dtype=np.uint8)
  data = data.reshape(len(label), 28, 28, 1)
 
- array_fn = _mx_np.array if is_np_array() else nd.array
- self._data = array_fn(data, dtype=data.dtype)
+ self._data = nd.array(data, dtype=data.dtype)
  self._label = label
 
 
@@ -188,9 +183,8 @@ def _get_data(self):
  data = np.concatenate(data)
  label = np.concatenate(label)
 
- array_fn = _mx_np.array if is_np_array() else nd.array
- self._data = array_fn(data, dtype=data.dtype)
- self._label = array_fn(label, dtype=label.dtype) if is_np_array() else label
+ self._data = nd.array(data, dtype=data.dtype)
+ self._label = label
 
 
 class CIFAR100(CIFAR10):

python/mxnet/gluon/data/vision/transforms.py

@@ -23,7 +23,6 @@
 from ...nn import Sequential, HybridSequential
 from .... import image
 from ....base import numeric_types
-from ....util import is_np_array
 
 
 class Compose(Sequential):
@@ -93,8 +92,6 @@ def __init__(self, dtype='float32'):
  self._dtype = dtype
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.cast(x, self._dtype)
 
 
@@ -137,8 +134,6 @@ def __init__(self):
  super(ToTensor, self).__init__()
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.to_tensor(x)
 
 
@@ -192,8 +187,6 @@ def __init__(self, mean=0.0, std=1.0):
  self._std = std
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.normalize(x, self._mean, self._std)
 
 
@@ -376,8 +369,6 @@ def __init__(self, size, keep_ratio=False, interpolation=1):
  self._interpolation = interpolation
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.resize(x, self._size, self._keep, self._interpolation)
 
 class RandomFlipLeftRight(HybridBlock):
@@ -394,8 +385,6 @@ def __init__(self):
  super(RandomFlipLeftRight, self).__init__()
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_flip_left_right(x)
 
 
@@ -413,8 +402,6 @@ def __init__(self):
  super(RandomFlipTopBottom, self).__init__()
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_flip_top_bottom(x)
 
 
@@ -440,8 +427,6 @@ def __init__(self, brightness):
  self._args = (max(0, 1-brightness), 1+brightness)
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_brightness(x, *self._args)
 
 
@@ -467,8 +452,6 @@ def __init__(self, contrast):
  self._args = (max(0, 1-contrast), 1+contrast)
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_contrast(x, *self._args)
 
 
@@ -494,8 +477,6 @@ def __init__(self, saturation):
  self._args = (max(0, 1-saturation), 1+saturation)
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_saturation(x, *self._args)
 
 
@@ -521,8 +502,6 @@ def __init__(self, hue):
  self._args = (max(0, 1-hue), 1+hue)
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_hue(x, *self._args)
 
 
@@ -557,8 +536,6 @@ def __init__(self, brightness=0, contrast=0, saturation=0, hue=0):
  self._args = (brightness, contrast, saturation, hue)
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_color_jitter(x, *self._args)
 
 
@@ -582,6 +559,4 @@ def __init__(self, alpha):
  self._alpha = alpha
 
  def hybrid_forward(self, F, x):
- if is_np_array():
- F = F.npx
  return F.image.random_lighting(x, self._alpha)

python/mxnet/gluon/loss.py

@@ -29,7 +29,6 @@
 from .. import ndarray
 from ..base import numeric_types
 from .block import HybridBlock
-from ..util import is_np_array
 
 
 def _apply_weighting(F, loss, weight=None, sample_weight=None):
@@ -54,10 +53,7 @@ def _apply_weighting(F, loss, weight=None, sample_weight=None):
  Weighted loss
  """
  if sample_weight is not None:
- if is_np_array():
- loss = loss * sample_weight
- else:
- loss = F.broadcast_mul(loss, sample_weight)
+ loss = F.broadcast_mul(loss, sample_weight)
 
  if weight is not None:
  assert isinstance(weight, numeric_types), "weight must be a number"
@@ -68,11 +64,7 @@ def _apply_weighting(F, loss, weight=None, sample_weight=None):
 
 def _reshape_like(F, x, y):
  """Reshapes x to the same shape as y."""
- if F is ndarray:
- return x.reshape(y.shape)
- elif is_np_array():
- F = F.npx
- return F.reshape_like(x, y)
+ return x.reshape(y.shape) if F is ndarray else F.reshape_like(x, y)
 
 
 class Loss(HybridBlock):
@@ -144,15 +136,9 @@ def __init__(self, weight=1., batch_axis=0, **kwargs):
 
  def hybrid_forward(self, F, pred, label, sample_weight=None):
  label = _reshape_like(F, label, pred)
- loss = F.np.square(label - pred) if is_np_array() else F.square(label - pred)
+ loss = F.square(label - pred)
  loss = _apply_weighting(F, loss, self._weight / 2, sample_weight)
- if is_np_array():
- if F is ndarray:
- return F.np.mean(loss, axis=tuple(range(1, loss.ndim)))
- else:
- return F.npx.batch_flatten(loss).mean(axis=1)
- else:
- return F.mean(loss, axis=self._batch_axis, exclude=True)
+ return F.mean(loss, axis=self._batch_axis, exclude=True)
 
 
 class L1Loss(Loss):
@@ -258,45 +244,27 @@ def __init__(self, from_sigmoid=False, weight=None, batch_axis=0, **kwargs):
 
  def hybrid_forward(self, F, pred, label, sample_weight=None, pos_weight=None):
  label = _reshape_like(F, label, pred)
- if is_np_array():
- relu_fn = F.npx.relu
- act_fn = F.npx.activation
- abs_fn = F.np.abs
- mul_fn = F.np.multiply
- log_fn = F.np.log
- else:
- relu_fn = F.relu
- act_fn = F.Activation
- abs_fn = F.abs
- mul_fn = F.broadcast_mul
- log_fn = F.log
  if not self._from_sigmoid:
  if pos_weight is None:
  # We use the stable formula: max(x, 0) - x * z + log(1 + exp(-abs(x)))
- loss = relu_fn(pred) - pred * label + \
- act_fn(-abs_fn(pred), act_type='softrelu')
+ loss = F.relu(pred) - pred * label + \
+ F.Activation(-F.abs(pred), act_type='softrelu')
  else:
  # We use the stable formula: x - x * z + (1 + z * pos_weight - z) * \
  # (log(1 + exp(-abs(x))) + max(-x, 0))
- log_weight = 1 + mul_fn(pos_weight - 1, label)
- loss = pred - pred * label + log_weight *\
- (act_fn(-abs_fn(pred), act_type='softrelu') + relu_fn(-pred))
+ log_weight = 1 + F.broadcast_mul(pos_weight - 1, label)
+ loss = pred - pred * label + log_weight * \
+ (F.Activation(-F.abs(pred), act_type='softrelu') + F.relu(-pred))
  else:
  eps = 1e-12
  if pos_weight is None:
- loss = -(log_fn(pred + eps) * label
- + log_fn(1. - pred + eps) * (1. - label))
+ loss = -(F.log(pred + eps) * label
+ + F.log(1. - pred + eps) * (1. - label))
  else:
- loss = -(mul_fn(log_fn(pred + eps) * label, pos_weight)
- + log_fn(1. - pred + eps) * (1. - label))
+ loss = -(F.broadcast_mul(F.log(pred + eps) * label, pos_weight)
+ + F.log(1. - pred + eps) * (1. - label))
  loss = _apply_weighting(F, loss, self._weight, sample_weight)
- if is_np_array():
- if F is ndarray:
- return F.np.mean(loss, axis=tuple(range(1, loss.ndim)))
- else:
- return F.npx.batch_flatten(loss).mean(axis=1)
- else:
- return F.mean(loss, axis=self._batch_axis, exclude=True)
+ return F.mean(loss, axis=self._batch_axis, exclude=True)
 
 
 SigmoidBCELoss = SigmoidBinaryCrossEntropyLoss
@@ -373,27 +341,15 @@ def __init__(self, axis=-1, sparse_label=True, from_logits=False, weight=None,
  self._from_logits = from_logits
 
  def hybrid_forward(self, F, pred, label, sample_weight=None):
- if is_np_array():
- log_softmax = F.npx.log_softmax
- pick = F.npx.pick
- else:
- log_softmax = F.log_softmax
- pick = F.pick
  if not self._from_logits:
- pred = log_softmax(pred, self._axis)
+ pred = F.log_softmax(pred, self._axis)
  if self._sparse_label:
- loss = -pick(pred, label, axis=self._axis, keepdims=True)
+ loss = -F.pick(pred, label, axis=self._axis, keepdims=True)
  else:
  label = _reshape_like(F, label, pred)
- loss = -(pred * label).sum(axis=self._axis, keepdims=True)
+ loss = -F.sum(pred * label, axis=self._axis, keepdims=True)
  loss = _apply_weighting(F, loss, self._weight, sample_weight)
- if is_np_array():
- if F is ndarray:
- return loss.mean(axis=tuple(range(1, loss.ndim)))
- else:
- return F.npx.batch_flatten(loss).mean(axis=1)
- else:
- return loss.mean(axis=self._batch_axis, exclude=True)
+ return F.mean(loss, axis=self._batch_axis, exclude=True)
 
 
 SoftmaxCELoss = SoftmaxCrossEntropyLoss