How to detect input lumpy from python side is c-order or f-order or either of them?

[lucasjinreal]

I want normalize the data to c-order, users sometimes send f-prder, sometimes non of them.

How to normalize it?

C_CONTIGUOUS : False
  F_CONTIGUOUS : False
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

[jiwaszki]

@jinfagang it is fairly simple when using pybind's numpy interface pybind::array. Generally it can be used like this (and similar works for other flags like F_CONTIGUOUS):

// Create some alias for the value
#define C_CONTIGUOUS py::detail::npy_api::constants::NPY_ARRAY_C_CONTIGUOUS_

return_value func(py::array array) {
    // This check is kind of "low-level" approach
    if (!(C_CONTIGUOUS == (array.flags() & C_CONTIGUOUS))) {
        // Actual casting, notice that type needs to be known and adding `c_style` is required to force memory alignment
        auto c_array = array.cast<py::array_t<double, py::array::c_style | py::array::forcecast>>();
    }
    // ...
}

I leave details of casting mechanism up to you, it depends on your actual problem. Let me know if it helps 😉

[lucasjinreal]

@jiwaszki thanks. My usage is like this: users send in a list of numpy arrays, these arrays needs to normalize:

Do u think my modification should work?

[jiwaszki]

What is the modification?

You are making a copy of inputs[i] to temporary py::array a. Later you cast it when it is not C-style contiguous (BTW remove auto it will throw an error and rename array to a, or change everything accordingly in a flow of the function). Now you take some pointer which is now float type(? - you should match it with above cast so data is not trimmed/corrupted) and do something with it. At the very end, I assume you append this a to in_tensors vector.

IF you make a copy and do not modify flags in-between - this should do the trick. You can simply check it with test - does returned arrays are C-style on Python side? Ref: https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags

[lucasjinreal]

@jiwaszki thank u so much for the suggestions! I now change it into:

inline std::vector<py::array> infer(std::vector<py::array> &inputs) {
    std::vector<Tensor> in_tensors;
    for (int i = 0; i < inputs.size(); ++i) {
      // normalize a to c-order
      if (!(C_CONTIGUOUS == (inputs[i].flags() & C_CONTIGUOUS))) {
        // Actual casting, notice that type needs to be known and adding
        // `c_style` is required to force memory alignment
        inputs[i] = inputs[i].cast<
            py::array_t<double, py::array::c_style | py::array::forcecast>>();
      }

      py::buffer_info buf1 = inputs[i].request();
      float *ptr1 = static_cast<float *>(buf1.ptr);
      Tensor at;
      ShapeType sh;
      get_shapetype(&buf1, sh);
      at.Create(ptr1, sh, DT_FLOAT);
      in_tensors.emplace_back(at);
    }
}

Now, as you can see, the cast is to double, what I take is float, but I should automatically match with users input,

how to get input array datatype here?>

(at the very end, I convert the array to a Tensor object and push to in_tensors, which is needed in by c++ forward real function, it can't take numpy array direclty)