Skip to content
This repository has been archived by the owner on Nov 17, 2023. It is now read-only.

Commit

Permalink
test CI 3
Browse files Browse the repository at this point in the history
  • Loading branch information
@JiangZhaoh
JiangZhaoh committed Feb 12, 2020
1 parent 0eeed52 commit dcd55e0
Show file tree
Hide file tree
Showing 10 changed files with 517 additions and 483 deletions.
2 changes: 1 addition & 1 deletion python/mxnet/numpy_dispatch_protocol.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -108,7 +108,7 @@ def _run_with_array_ufunc_proto(*args, **kwargs):
'flipud',
'fliplr',
'inner',
'insert',
# 'insert',
'max',
'amax',
'mean',
Expand Down
7 changes: 1 addition & 6 deletions python/mxnet/symbol/numpy/_symbol.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,13 +40,8 @@
'delete', 'add', 'broadcast_to', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power', 'arctan2',
'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10', 'sqrt', 'cbrt', 'abs', 'absolute', 'exp',
'expm1', 'arcsin', 'arccos', 'arctan', 'sign', 'log', 'degrees', 'log2', 'log1p',
<<<<<<< 6c61afbc10efd0c40be1977ad22b5ec016d694fc
'rint', 'radians', 'reciprocal', 'square', 'negative', 'fix', 'ceil', 'floor', 'histogram',
'trunc', 'logical_not', 'arcsinh', 'arccosh', 'arctanh', 'argsort', 'sort', 'tensordot', 'eye', 'linspace',
=======
'rint', 'radians', 'reciprocal', 'square', 'negative', 'fix', 'ceil', 'floor', 'histogram', 'insert',
'trunc', 'logical_not', 'arcsinh', 'arccosh', 'arctanh', 'argsort', 'tensordot', 'eye', 'linspace',
>>>>>>> add op insert
'trunc', 'logical_not', 'arcsinh', 'arccosh', 'arctanh', 'argsort', 'sort', 'tensordot', 'eye', 'linspace',
'logspace', 'expand_dims', 'tile', 'arange', 'array_split', 'split', 'vsplit', 'concatenate', 'append',
'stack', 'vstack', 'row_stack', 'column_stack', 'hstack', 'dstack',
'average', 'mean', 'maximum', 'minimum',
Expand Down
74 changes: 13 additions & 61 deletions src/operator/numpy/np_insert_op-inl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -316,7 +316,7 @@ void InsertScalerObj(mshadow::Stream<xpu> *s, const TBlob& output,
}

template<typename xpu, int ndim>
void InsertSizeOneTensorObj(mshadow::Stream<xpu> *s, const TBlob& output,
void InsertSizeOneTensorImpl(mshadow::Stream<xpu> *s, const TBlob& output,
const TBlob& arr, const TBlob& values,
const mshadow::Shape<ndim>& arr_strides,
const mshadow::Shape<ndim>& val_strides,
Expand All @@ -342,7 +342,7 @@ void InsertSizeOneTensorObj(mshadow::Stream<xpu> *s, const TBlob& output,
}

template<typename xpu, int ndim>
void InsertSequenceObj(mshadow::Stream<xpu> *s, const TBlob& output,
void InsertSequenceImpl(mshadow::Stream<xpu> *s, const TBlob& output,
const TBlob& arr, const TBlob& values,
const mshadow::Shape<ndim>& arr_strides,
const mshadow::Shape<ndim>& val_strides,
Expand All @@ -365,53 +365,13 @@ void InsertSequenceObj(mshadow::Stream<xpu> *s, const TBlob& output,
});
}

template<typename xpu>
void InsertScalarIndicesImpl(const OpContext &ctx,
const TShape& outshape, const TShape& old_valshape,
const std::vector<TBlob>& inputs,
const std::vector<TBlob>& outputs,
const TBlob& arr, const TBlob& values,
const int& dtype, const int& vtype,
const std::vector<OpReqType>& req,
const int& axis, const int& index,
const int& out_pos, const int& obj_pos,
const int& numnew, const int& N,
const bool& is_tensor);

template<typename xpu>
void InsertOneIndicesImpl(const OpContext &ctx,
const TShape& outshape, const TShape& old_valshape,
const NumpyInsertParam& param,
const std::vector<TBlob>& inputs,
const std::vector<TBlob>& outputs,
const TBlob& arr, const TBlob& values,
const int& dtype, const int& vtype,
const std::vector<OpReqType>& req,
const int& axis, const int& start,
const int& out_pos, const int& obj_pos,
const int& numnew, const int& N);

template<typename xpu>
void InsertTensorIndicesImpl(const OpContext &ctx,
const TShape& outshape,
const NumpyInsertParam& param,
const std::vector<TBlob>& inputs,
const std::vector<TBlob>& outputs,
const TBlob& arr, const TBlob& values,
const int& dtype, const int& vtype,
const std::vector<OpReqType>& req,
const int& axis, const int& start,
const int& step, const int&indices_len,
const int& out_pos, const int& obj_pos,
const int& numnew, const int& N);

template<typename xpu>
void NumpyInsertCompute(const nnvm::NodeAttrs& attrs,
const OpContext& ctx,
const std::vector<TBlob>& inputs,
const std::vector<OpReqType>& req,
const std::vector<TBlob>& outputs) {
using namespace mshadow;
/*using namespace mshadow;
using namespace mxnet_op;
const NumpyInsertParam& param = nnvm::get<NumpyInsertParam>(attrs.parsed);
Expand Down Expand Up @@ -547,9 +507,7 @@ void NumpyInsertCompute(const nnvm::NodeAttrs& attrs,
if (param.int_ind.has_value()) {
// 'obj' is integer, need to moveaxis
InsertScalarIndicesImpl<xpu>(ctx, outshape, old_valshape, inputs, outputs, arr, values,
dtype, vtype, req, axis, index, out_pos, obj_pos, numnew, N, false);
/*MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
InsertScalerObj<xpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
Expand All @@ -558,12 +516,10 @@ void NumpyInsertCompute(const nnvm::NodeAttrs& attrs,
outshape.get<ndim>(), values.shape_.get<ndim>(),
dtype, vtype, req[out_pos], axis, index, numnew,
outshape.Size(), true);
});*/
});
} else if (obj_is_tensor && inputs[obj_pos].shape_.ndim() == 0) {
// 'obj' is tensor and the tensor's ndim is 0, also need to moveaxis
InsertScalarIndicesImpl<xpu>(ctx, outshape, old_valshape, inputs, outputs, arr, values,
dtype, vtype, req, axis, index, out_pos, obj_pos, numnew, N, true);
/*MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
InsertSizeOneTensorObj<xpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
Expand All @@ -573,11 +529,9 @@ void NumpyInsertCompute(const nnvm::NodeAttrs& attrs,
dtype, vtype, req[out_pos], axis, inputs[obj_pos],
numnew, N, outshape.Size(), true);
});*/
});
} else if (indices_len == 1) {
InsertOneIndicesImpl<xpu>(ctx, outshape, old_valshape, param, inputs, outputs, arr, values,
dtype, vtype, req, axis, start, out_pos, obj_pos, numnew, N);
/*MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
if (param.step.has_value()) {
InsertScalerObj<xpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
Expand All @@ -597,12 +551,10 @@ void NumpyInsertCompute(const nnvm::NodeAttrs& attrs,
dtype, vtype, req[out_pos], axis, inputs[obj_pos],
numnew, N, outshape.Size(), false);
}
});*/
});
} else {
// broadcast check
InsertTensorIndicesImpl<xpu>(ctx, outshape, param, inputs, outputs, arr, values, dtype, vtype,
req, axis, start, step, indices_len, out_pos, obj_pos, numnew, N);
/*for (int i = outshape.ndim() - 1; i >= 0; --i) {
for (int i = outshape.ndim() - 1; i >= 0; --i) {
int sz = outshape[i];
if (i == axis) {
sz = numnew;
Expand Down Expand Up @@ -644,16 +596,16 @@ void NumpyInsertCompute(const nnvm::NodeAttrs& attrs,
Kernel<SetOriginValuesIdx, xpu>::Launch(s, indices_len, indices_ptr, origin_idx);
Kernel<SetOriginArrIdx, xpu>::Launch(s, outshape[axis], is_insert, origin_idx);
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
InsertSequenceObj<xpu, ndim>(s, outputs[out_pos], arr, values,
InsertSequenceImpl<xpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
mxnet_op::calc_stride(outshape.get<ndim>()),
outshape.get<ndim>(), values.shape_.get<ndim>(),
is_insert, origin_idx, dtype, vtype, req[out_pos],
axis, outshape.Size());
});*/
}
});
}*/
}

} // namespace op
Expand Down
149 changes: 0 additions & 149 deletions src/operator/numpy/np_insert_op.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -159,155 +159,6 @@ bool NumpyInsertShape(const nnvm::NodeAttrs& attrs,
return shape_is_known(newshape);
}

template<>
void InsertScalarIndicesImpl<cpu>(const OpContext &ctx,
const TShape& outshape, const TShape& old_valshape,
const std::vector<TBlob>& inputs,
const std::vector<TBlob>& outputs,
const TBlob& arr, const TBlob& values,
const int& dtype, const int& vtype,
const std::vector<OpReqType>& req,
const int& axis, const int& index,
const int& out_pos, const int& obj_pos,
const int& numnew, const int& N,
const bool& is_tensor){
using namespace mshadow;
using namespace mxnet_op;
mshadow::Stream<cpu> *s = ctx.get_stream<cpu>();
if (is_tensor) {
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
InsertSizeOneTensorObj<cpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
mxnet_op::calc_stride(old_valshape.get<ndim>()),
mxnet_op::calc_stride(outshape.get<ndim>()),
outshape.get<ndim>(), values.shape_.get<ndim>(),
dtype, vtype, req[out_pos], axis, inputs[obj_pos],
numnew, N, outshape.Size(), true);

});
} else {
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
InsertScalerObj<cpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
mxnet_op::calc_stride(old_valshape.get<ndim>()),
mxnet_op::calc_stride(outshape.get<ndim>()),
outshape.get<ndim>(), values.shape_.get<ndim>(),
dtype, vtype, req[out_pos], axis, index, numnew,
outshape.Size(), true);
});
}
}

template<>
void InsertOneIndicesImpl<cpu>(const OpContext &ctx,
const TShape& outshape, const TShape& old_valshape,
const NumpyInsertParam& param,
const std::vector<TBlob>& inputs,
const std::vector<TBlob>& outputs,
const TBlob& arr, const TBlob& values,
const int& dtype, const int& vtype,
const std::vector<OpReqType>& req,
const int& axis, const int& start,
const int& out_pos, const int& obj_pos,
const int& numnew, const int& N){
using namespace mshadow;
using namespace mxnet_op;
mshadow::Stream<cpu> *s = ctx.get_stream<cpu>();
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
if (param.step.has_value()) {
InsertScalerObj<cpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
mxnet_op::calc_stride(old_valshape.get<ndim>()),
mxnet_op::calc_stride(outshape.get<ndim>()),
outshape.get<ndim>(), values.shape_.get<ndim>(),
dtype, vtype, req[out_pos], axis, start, numnew,
outshape.Size(), false);
} else {
InsertSizeOneTensorObj<cpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
mxnet_op::calc_stride(old_valshape.get<ndim>()),
mxnet_op::calc_stride(outshape.get<ndim>()),
outshape.get<ndim>(), values.shape_.get<ndim>(),
dtype, vtype, req[out_pos], axis, inputs[obj_pos],
numnew, N, outshape.Size(), false);
}
});
}

template<>
void InsertTensorIndicesImpl<cpu>(const OpContext &ctx,
const TShape& outshape,
const NumpyInsertParam& param,
const std::vector<TBlob>& inputs,
const std::vector<TBlob>& outputs,
const TBlob& arr, const TBlob& values,
const int& dtype, const int& vtype,
const std::vector<OpReqType>& req,
const int& axis, const int& start,
const int& step, const int&indices_len,
const int& out_pos, const int& obj_pos,
const int& numnew, const int& N){
using namespace mshadow;
using namespace mxnet_op;
mshadow::Stream<cpu> *s = ctx.get_stream<cpu>();

for (int i = outshape.ndim() - 1; i >= 0; --i) {
int sz = outshape[i];
if (i == axis) {
sz = numnew;
}
CHECK((values.shape_[i] == 1) || (values.shape_[i] == sz));
}
size_t temp_storage_bytes, temp_mem_size;
temp_storage_bytes = SortByKeyWorkspaceSize<int64_t, int, cpu>(indices_len, false, true);
temp_mem_size = indices_len * sizeof(int64_t) * 2 +
indices_len * sizeof(int) +
outshape[axis] * sizeof(int) * 2 +
temp_storage_bytes;
Tensor<cpu, 1, char> temp_mem =
ctx.requested[0].get_space_typed<cpu, 1, char>(Shape1(temp_mem_size), s);
int64_t* indices_ptr = reinterpret_cast<int64_t*>(temp_mem.dptr_);
int64_t* sorted_indices_ptr = reinterpret_cast<int64_t*>(indices_ptr + indices_len);
int* order_ptr = reinterpret_cast<int*>(sorted_indices_ptr + indices_len);
int* is_insert = reinterpret_cast<int*>(order_ptr + indices_len);
int* origin_idx = reinterpret_cast<int*>(is_insert + outshape[axis]);
Tensor<cpu, 1, char> temp_storage(reinterpret_cast<char*>(origin_idx + outshape[axis]),
Shape1(temp_storage_bytes), s);
Tensor<cpu, 1, int64_t> indices(indices_ptr, Shape1(indices_len), s);
Tensor<cpu, 1, int64_t> sorted_indices(sorted_indices_ptr, Shape1(indices_len), s);
Tensor<cpu, 1, int> order(order_ptr, Shape1(indices_len), s);
int num_bits = common::ilog2ui(static_cast<unsigned int>(indices_len) - 1);
if (param.step.has_value()) {
Kernel<SliceToIndices, cpu>::Launch(s, indices_len, indices_ptr, start, step);
} else {
Kernel<ObjToIndices, cpu>::Launch(s, indices_len, indices_ptr, N,
inputs[obj_pos].dptr<int64_t>());
}
Kernel<range_fwd, cpu>::Launch(s, indices_len, 1, 0, 1, kWriteTo, order_ptr);
mxnet::op::SortByKey(indices, order, true, &temp_storage, 0, num_bits, &sorted_indices);
Kernel<IndicesModify, cpu>::Launch(s, indices_len, indices_ptr, order_ptr);

mxnet_op::Kernel<mxnet_op::set_zero, cpu>::Launch(s, outshape[axis], is_insert);
Kernel<SetIsInsert, cpu>::Launch(s, indices_len, indices_ptr, is_insert);

Kernel<SetOriginValuesIdx, cpu>::Launch(s, indices_len, indices_ptr, origin_idx);
Kernel<SetOriginArrIdx, cpu>::Launch(s, outshape[axis], is_insert, origin_idx);
MXNET_NDIM_SWITCH(outshape.ndim(), ndim, {
InsertSequenceObj<cpu, ndim>(s, outputs[out_pos], arr, values,
mxnet_op::calc_stride(arr.shape_.get<ndim>()),
mxnet_op::calc_stride(values.shape_.get<ndim>()),
mxnet_op::calc_stride(outshape.get<ndim>()),
outshape.get<ndim>(), values.shape_.get<ndim>(),
is_insert, origin_idx, dtype, vtype, req[out_pos],
axis, outshape.Size());

});
}

NNVM_REGISTER_OP(_npi_insert)
.describe(R"code(Insert values along the given axis before the given indices.)code" ADD_FILELINE)
.set_attr_parser(ParamParser<NumpyInsertParam>)
Expand Down
Loading

0 comments on commit dcd55e0

Please sign in to comment.