BUG: make array-detection logic in array(...) more robust

[ev-br]

Needed for arrays hiding as elements of nested lists e.g. np.array([[1, 2], [3, np.array(4)]]).

Split off from gh-137.

[lezcano]

Bring here the if obj is isntance list/tuple, otherwise this function assumes that obj is an iterable, whcih is a non-trivial thing to assume in this context.

[ev-br]

It's guarded with an if isinstance check at the call site?
https://github.com/Quansight-Labs/numpy_pytorch_interop/pull/138/files#diff-83812bd01681b687b8fced4eac464b076aecffc471e0364d905b38fba8794e6cR487

[lezcano]

Yeah. What I'm saying is that the logic of this function assumes that if implicitly. The if instance should be inside this function, not in the caller site..

[lezcano]

Also, in what context do we need this? as_tensor already seems to do this:

>>>torch.as_tensor([[2,3], np.array([2,3])])
tensor([[2, 3],
        [2, 3]])

[ev-br]

In main, it only looks into the first level of nesting:

In [3]: tnp.array([[1, 2], [tnp.int8(1), 2]])
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[3], line 1
----> 1 tnp.array([[1, 2], [tnp.int8(1), 2]])

File ~/sweethome/proj/scipy/torch_np_compat/torch_np/_ndarray.py:495, in array(obj, dtype, copy, order, subok, ndmin, like)
    493 def array(obj, dtype=None, *, copy=True, order="K", subok=False, ndmin=0, like=None):
    494     # The result of the public `np.array(obj)` is not weakly typed.
--> 495     return _array(obj, dtype, copy=copy, order=order, subok=subok, ndmin=ndmin, like=like, is_weak=False)

File ~/sweethome/proj/scipy/torch_np_compat/torch_np/_ndarray.py:489, in _array(obj, dtype, copy, order, subok, ndmin, like, is_weak)
    486 if dtype is not None:
    487     torch_dtype = _dtypes.dtype(dtype).torch_dtype
--> 489 tensor = _util._coerce_to_tensor(obj, torch_dtype, copy, ndmin, is_weak)
    490 return ndarray(tensor)

File ~/sweethome/proj/scipy/torch_np_compat/torch_np/_util.py:213, in _coerce_to_tensor(obj, dtype, copy, ndmin, is_weak)
    211     tensor = torch.as_tensor(obj, dtype=dtype)
    212 else:
--> 213     tensor = torch.as_tensor(obj)
    215     # tensor.dtype is the pytorch default, typically float32. If obj's elements
    216     # are not exactly representable in float32, we've lost precision:
    217     # >>> torch.as_tensor(1e12).item() - 1e12
   (...)
    220     # Therefore, we treat `tensor.dtype` as a hint, and convert the
    221     # original object *again*, this time with an explicit dtype.
    222     torch_dtype = _dtypes_impl.get_default_dtype_for(tensor.dtype)

File ~/sweethome/proj/scipy/torch_np_compat/torch_np/_ndarray.py:391, in ndarray.__len__(self)
    390 def __len__(self):
--> 391     return self.tensor.shape[0]

IndexError: tuple index out of range

A smoke test is https://github.com/Quansight-Labs/numpy_pytorch_interop/pull/138/files#diff-66e581e6a3a373197465b30dd84684d915c83f3c619773382e8f8a40140662a5R558

EDIT: the traceback shows it's not from a branch not main, but the point stands.

[lezcano]

But I think this works in PyTorch?

>>> torch.as_tensor([[1,2],[np.int8(1), 2]])
tensor([[1, 2],
        [1, 2]])

[ev-br]

With numpy ndarrays, yes. With torch_np wrapper ndarrays, not in main, yes with this PR.

[lezcano]

Then why calling tolist()? Shouldn't we just unwrap the tensor if it's a tnp array and call item() if it's of weak dtype?

[lezcano]

nvm, I just read #138 (comment). Can you add a comment explaining this point?

[ev-br]

Note that this function is almost identical to _helpers/ndarrays_to_tensors, which is used for fancy indexing and basically converts nested arrays to tensors. Letting go of .tolist() here sounded tempting but does not quite work because numpy allows, for instance,

(Pdb) import numpy as _np
(Pdb) p x
array([[1., 2.],
       [3., 4.]], dtype=float32)
(Pdb) _np.asarray([x, 2*x, 3*x])
array([[[ 1.,  2.],
        [ 3.,  4.]],

       [[ 2.,  4.],
        [ 6.,  8.]],

       [[ 3.,  6.],
        [ 9., 12.]]], dtype=float32)

(Pdb) import torch
(Pdb) t
tensor([[1., 2.],
        [3., 4.]])
(Pdb) torch.as_tensor([t, 2*t, 3*t])
*** ValueError: only one element tensors can be converted to Python scalars

[lezcano]

Just missing a couple nits discussed in the comments, but otherwise LGTM.

[lezcano]

nit Recursively

[lezcano]

As discussed offline, this may be not super efficient, but we don't care about tracing efficiency atm, so in it goes.