Revert apache#15842 and apache#15894. These PRs should not modify CI timeouts.

Author: larroy

ci/jenkins/Jenkinsfile_unix_cpu

@@ -21,7 +21,7 @@
 // See documents at https://jenkins.io/doc/book/pipeline/jenkinsfile/
 
 // timeout in minutes
-max_time = 240
+max_time = 180
 
 node('utility') {
   // Loading the utilities requires a node context unfortunately

python/mxnet/ndarray/numpy/_op.py

@@ -27,7 +27,7 @@
 from ..ndarray import NDArray
 
 __all__ = ['zeros', 'ones', 'add', 'subtract', 'multiply', 'divide', 'mod', 'power', 'tensordot',
-           'linspace', 'expand_dims', 'tile', 'arange', 'split', 'concatenate', 'stack']
+           'linspace', 'expand_dims', 'tile', 'arange', 'split']
 
 
 @set_module('mxnet.ndarray.numpy')
@@ -682,53 +682,3 @@ def split(ary, indices_or_sections, axis=0):
     if not isinstance(ret, list):
         return [ret]
     return ret
-
-
-@set_module('mxnet.ndarray.numpy')
-def concatenate(seq, axis=0, out=None):
-    """Join a sequence of arrays along an existing axis.
-    Parameters
-    ----------
-    a1, a2, ... : sequence of array_like
-        The arrays must have the same shape, except in the dimension
-        corresponding to `axis` (the first, by default).
-    axis : int, optional
-        The axis along which the arrays will be joined.  If axis is None,
-        arrays are flattened before use.  Default is 0.
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be
-        correct, matching that of what concatenate would have returned if no
-        out argument were specified.
-    Returns
-    -------
-    res : ndarray
-        The concatenated array.
-    """
-    return _npi.concatenate(*seq, dim=axis, out=out)
-
-
-@set_module('mxnet.ndarray.numpy')
-def stack(arrays, axis=0, out=None):
-    """Join a sequence of arrays along a new axis.
-        The axis parameter specifies the index of the new axis in the dimensions of the result.
-        For example, if `axis=0` it will be the first dimension and if `axis=-1` it will be the last dimension.
-    Parameters
-    ----------
-    arrays : sequence of array_like
-        Each array must have the same shape.
-    axis : int, optional
-        The axis in the result array along which the input arrays are stacked.
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be correct,
-        matching that of what stack would have returned if no out argument were specified.
-    Returns
-    -------
-    stacked : ndarray
-        The stacked array has one more dimension than the input arrays."""
-    def get_list(arrays):
-        if not hasattr(arrays, '__getitem__') and hasattr(arrays, '__iter__'):
-            raise ValueError("expected iterable for arrays but got {}".format(type(arrays)))
-        return [arr for arr in arrays]
-
-    arrays = get_list(arrays)
-    return _npi.stack(*arrays, axis=axis, out=out)

python/mxnet/numpy/multiarray.py

@@ -44,8 +44,7 @@
 from ..ndarray.numpy import _internal as _npi
 
 __all__ = ['ndarray', 'empty', 'array', 'zeros', 'ones', 'add', 'subtract', 'multiply', 'divide',
-           'mod', 'power', 'tensordot', 'linspace', 'expand_dims', 'tile', 'arange', 'split',
-           'concatenate', 'stack']
+           'mod', 'power', 'tensordot', 'linspace', 'expand_dims', 'tile', 'arange', 'split']
 
 
 # This function is copied from ndarray.py since pylint
@@ -1854,47 +1853,3 @@ def split(ary, indices_or_sections, axis=0):
         If `indices_or_sections` is given as an integer, but
         a split does not result in equal division."""
     return _mx_nd_np.split(ary, indices_or_sections, axis=axis)
-
-
-@set_module('mxnet.numpy')
-def concatenate(seq, axis=0, out=None):
-    """Join a sequence of arrays along an existing axis.
-    Parameters
-    ----------
-    a1, a2, ... : sequence of array_like
-        The arrays must have the same shape, except in the dimension
-        corresponding to `axis` (the first, by default).
-    axis : int, optional
-        The axis along which the arrays will be joined.  If axis is None,
-        arrays are flattened before use.  Default is 0.
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be
-        correct, matching that of what concatenate would have returned if no
-        out argument were specified.
-    Returns
-    -------
-    res : ndarray
-        The concatenated array.
-    """
-    return _mx_nd_np.concatenate(seq, axis=axis, out=out)
-
-
-@set_module('mxnet.numpy')
-def stack(arrays, axis=0, out=None):
-    """Join a sequence of arrays along a new axis.
-        The axis parameter specifies the index of the new axis in the dimensions of the result.
-        For example, if `axis=0` it will be the first dimension and if `axis=-1` it will be the last dimension.
-    Parameters
-    ----------
-    arrays : sequence of array_like
-        Each array must have the same shape.
-    axis : int, optional
-        The axis in the result array along which the input arrays are stacked.
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be correct,
-        matching that of what stack would have returned if no out argument were specified.
-    Returns
-    -------
-    stacked : ndarray
-        The stacked array has one more dimension than the input arrays."""
-    return _mx_nd_np.stack(arrays, axis=axis, out=out)

python/mxnet/symbol/numpy/_symbol.py

@@ -30,7 +30,7 @@
 from . import _internal as _npi
 
 __all__ = ['zeros', 'ones', 'add', 'subtract', 'multiply', 'divide', 'mod', 'power', 'tensordot',
-           'linspace', 'expand_dims', 'tile', 'arange', 'split', 'concatenate', 'stack']
+           'linspace', 'expand_dims', 'tile', 'arange', 'split']
 
 
 def _num_outputs(sym):
@@ -1312,54 +1312,4 @@ def split(ary, indices_or_sections, axis=0):
     return ret
 
 
-@set_module('mxnet.symbol.numpy')
-def concatenate(seq, axis=0, out=None):
-    """Join a sequence of arrays along an existing axis.
-    Parameters
-    ----------
-    a1, a2, ... : sequence of array_like
-        The arrays must have the same shape, except in the dimension
-        corresponding to `axis` (the first, by default).
-    axis : int, optional
-        The axis along which the arrays will be joined.  If axis is None,
-        arrays are flattened before use.  Default is 0.
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be
-        correct, matching that of what concatenate would have returned if no
-        out argument were specified.
-    Returns
-    -------
-    res : ndarray
-        The concatenated array.
-    """
-    return _npi.concatenate(*seq, dim=axis, out=out)
-
-
-@set_module('mxnet.symbol.numpy')
-def stack(arrays, axis=0, out=None):
-    """Join a sequence of arrays along a new axis.
-        The axis parameter specifies the index of the new axis in the dimensions of the result.
-        For example, if `axis=0` it will be the first dimension and if `axis=-1` it will be the last dimension.
-    Parameters
-    ----------
-    arrays : sequence of array_like
-        Each array must have the same shape.
-    axis : int, optional
-        The axis in the result array along which the input arrays are stacked.
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be correct,
-        matching that of what stack would have returned if no out argument were specified.
-    Returns
-    -------
-    stacked : ndarray
-        The stacked array has one more dimension than the input arrays."""
-    def get_list(arrays):
-        if not hasattr(arrays, '__getitem__') and hasattr(arrays, '__iter__'):
-            raise ValueError("expected iterable for arrays but got {}".format(type(arrays)))
-        return [arr for arr in arrays]
-
-    arrays = get_list(arrays)
-    return _npi.stack(*arrays, axis=axis, out=out)
-
-
 _set_np_symbol_class(_Symbol)

src/operator/numpy/np_matrix_op-inl.h

@@ -27,7 +27,6 @@
 
 #include <vector>
 #include "../tensor/matrix_op-inl.h"
-#include "../nn/concat-inl.h"
 
 namespace mxnet {
 namespace op {

src/operator/numpy/np_matrix_op.cc

@@ -23,8 +23,8 @@
  * \brief CPU Implementation of numpy matrix operations
  */
 
-#include <vector>
 #include "./np_matrix_op-inl.h"
+#include "../nn/concat-inl.h"
 
 namespace mxnet {
 namespace op {
@@ -248,102 +248,5 @@ NNVM_REGISTER_OP(_np_squeeze)
 .add_argument("a", "NDArray-or-Symbol[]", "data to squeeze")
 .add_arguments(SqueezeParam::__FIELDS__());
 
-bool ConcatShape(const nnvm::NodeAttrs& attrs,
-                 mxnet::ShapeVector *in_shape,
-                 mxnet::ShapeVector *out_shape);
-
-bool ConcatType(const nnvm::NodeAttrs& attrs,
-                std::vector<int> *in_type,
-                std::vector<int> *out_type);
-
-struct NumpyConcatGrad {
-  const char *op_name;
-  std::vector<nnvm::NodeEntry> operator()(const nnvm::NodePtr& n,
-                                          const std::vector<nnvm::NodeEntry>& ograds) const {
-    CHECK_EQ(ograds.size(), 1);
-    std::vector<nnvm::NodeEntry> heads(ograds.begin(), ograds.end());
-    return MakeGradNode(op_name, n, heads, n->attrs.dict);
-  }
-};
-
-
-NNVM_REGISTER_OP(_npi_concatenate)
-.describe(R"code(Join a sequence of arrays along an existing axis.)code" ADD_FILELINE)
-.set_num_inputs([](const NodeAttrs& attrs) {
-  const ConcatParam& params = nnvm::get<ConcatParam>(attrs.parsed);
-  return params.num_args;
-})
-.set_num_outputs(1)
-.set_attr_parser(ParamParser<ConcatParam>)
-.set_attr<nnvm::FListInputNames>("FListInputNames",
-  [](const NodeAttrs& attrs) {
-    const ConcatParam& params = nnvm::get<ConcatParam>(attrs.parsed);
-    std::vector<std::string> ret;
-    for (int i = 0; i < params.num_args; ++i) {
-      ret.push_back(std::string("data") + std::to_string(i));
-    }
-    return ret;
-})
-.set_attr<nnvm::FListOutputNames>("FListOutputNames",
-  [](const NodeAttrs& attrs) {
-    return std::vector<std::string>{"out"};
-})
-.set_attr<std::string>("key_var_num_args", "num_args")
-.set_attr<nnvm::FInferType>("FInferType", ConcatType)
-.set_attr<mxnet::FInferShape>("FInferShape", ConcatShape)
-.set_attr<FCompute>("FCompute<cpu>", ConcatCompute<cpu>)
-.set_attr<nnvm::FGradient>("FGradient", NumpyConcatGrad{"_backward_np_concat"})
-.add_argument("data", "NDArray-or-Symbol[]", "List of arrays to concatenate")
-.add_arguments(ConcatParam::__FIELDS__());
-
-NNVM_REGISTER_OP(_backward_np_concat)
-.set_num_outputs([](const NodeAttrs& attrs) {
-  const ConcatParam& params = nnvm::get<ConcatParam>(attrs.parsed);
-  return params.num_args;
-})
-.set_attr_parser(ParamParser<ConcatParam>)
-.set_attr<nnvm::TIsBackward>("TIsBackward", true)
-.set_attr<FCompute>("FCompute<cpu>", ConcatGradCompute<cpu>);
-
-NNVM_REGISTER_OP(_npi_stack)
-.describe(R"code(Join a sequence of arrays along a new axis.
-
-The axis parameter specifies the index of the new axis in the dimensions of the
-result. For example, if axis=0 it will be the first dimension and if axis=-1 it
-will be the last dimension.
-
-Examples::
-
-  x = [1, 2]
-  y = [3, 4]
-
-  stack(x, y) = [[1, 2],
-                 [3, 4]]
-  stack(x, y, axis=1) = [[1, 3],
-                         [2, 4]]
-)code")
-.set_num_inputs([](const nnvm::NodeAttrs& attrs) {
-    const StackParam& param = dmlc::get<StackParam>(attrs.parsed);
-    return static_cast<uint32_t>(param.num_args);
-  })
-.set_num_outputs(1)
-.set_attr_parser(ParamParser<StackParam>)
-.set_attr<nnvm::FListInputNames>("FListInputNames",
-  [](const NodeAttrs& attrs) {
-    uint32_t num_args = dmlc::get<StackParam>(attrs.parsed).num_args;
-    std::vector<std::string> ret;
-    for (uint32_t i = 0; i < num_args; ++i) {
-      ret.push_back(std::string("arg") + std::to_string(i));
-    }
-    return ret;
-  })
-.set_attr<std::string>("key_var_num_args", "num_args")
-.set_attr<mxnet::FInferShape>("FInferShape", StackOpShape)
-.set_attr<nnvm::FInferType>("FInferType", ElemwiseType<-1, 1>)
-.set_attr<FCompute>("FCompute<cpu>", StackOpForward<cpu>)
-.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseNone{"_backward_stack"})
-.add_argument("data", "NDArray-or-Symbol[]", "List of arrays to stack")
-.add_arguments(StackParam::__FIELDS__());
-
 }  // namespace op
 }  // namespace mxnet

src/operator/numpy/np_matrix_op.cu

@@ -22,8 +22,8 @@
  * \file np_matrix_op.cu
  * \brief GPU Implementation of numpy matrix operations
  */
-
 #include "./np_matrix_op-inl.h"
+#include "../nn/concat-inl.h"
 
 namespace mxnet {
 namespace op {
@@ -37,14 +37,5 @@ NNVM_REGISTER_OP(_np_reshape)
 NNVM_REGISTER_OP(_np_squeeze)
 .set_attr<FCompute>("FCompute<gpu>", UnaryOp::IdentityCompute<gpu>);
 
-NNVM_REGISTER_OP(_npi_concatenate)
-.set_attr<FCompute>("FCompute<gpu>", ConcatCompute<gpu>);
-
-NNVM_REGISTER_OP(_backward_np_concat)
-.set_attr<FCompute>("FCompute<gpu>", ConcatGradCompute<gpu>);
-
-NNVM_REGISTER_OP(_npi_stack)
-.set_attr<FCompute>("FCompute<gpu>", StackOpForward<gpu>);
-
 }  // namespace op
 }  // namespace mxnet