def dot(tensor1, tensor2):
"""Returns the matrix or dot product of two tensors.
* If both tensors are 0-dimensional, elementwise multiplication
is performed and a 0-dimensional scalar returned.
* If both tensors are 1-dimensional, the dot product is returned.
* If the first array is 2-dimensional and the second array 1-dimensional,
the matrix-vector product is returned.
* If both tensors are 2-dimensional, the matrix product is returned.
* Finally, if the the first array is N-dimensional and the second array
M-dimensional, a sum product over the last dimension of the first array,
and the second-to-last dimension of the second array is returned.
Args:
tensor1 (tensor_like): input tensor
tensor2 (tensor_like): input tensor
Returns:
tensor_like: the matrix or dot product of two tensors
"""
interface = _multi_dispatch([tensor1, tensor2])
x, y = np.coerce([tensor1, tensor2], like=interface)
if interface == "torch":
if x.ndim == 0 and y.ndim == 0:
return x * y
if x.ndim <= 2 and y.ndim <= 2:
return x @ y
return np.tensordot(x, y, dims=[[-1], [-2]], like=interface)
if interface == "tensorflow":
if x.ndim == 0 and y.ndim == 0:
return x * y
if y.ndim == 1:
return np.tensordot(x, y, axes=[[-1], [0]], like=interface)
if x.ndim == 2 and y.ndim == 2:
return x @ y
return np.tensordot(x, y, axes=[[-1], [-2]], like=interface)
return np.dot(x, y, like=interface)
def tensordot(tensor1, tensor2, axes=None, like=None):
"""Returns the tensor product of two tensors.
In general ``axes`` specifies either the set of axes for both
tensors that are contracted (with the first/second entry of ``axes``
giving all axis indices for the first/second tensor) or --- if it is
an integer --- the number of last/first axes of the first/second
tensor to contract over.
There are some non-obvious special cases:
* If both tensors are 0-dimensional, ``axes`` must be 0.
and a 0-dimensional scalar is returned containing the simple product.
* If both tensors are 1-dimensional and ``axes=0``, the outer product
is returned.
* Products between a non-0-dimensional and a 0-dimensional tensor are not
supported in all interfaces.
Args:
tensor1 (tensor_like): input tensor
tensor2 (tensor_like): input tensor
axes (int or list[list[int]]): Axes to contract over, see detail description.
Returns:
tensor_like: the tensor product of the two input tensors
"""
tensor1, tensor2 = np.coerce([tensor1, tensor2], like=like)
return np.tensordot(tensor1, tensor2, axes=axes, like=like)
def modified_gram_schmidt_np_mimic(X):
from autoray import numpy as np
print(np)
Q = []
for j in range(0, X.shape[0]):
q = X[j, :]
for i in range(0, j):
rij = np.tensordot(np.conj(Q[i]), q, 1)
q = q - rij * Q[i]
rjj = np.linalg.norm(q, 2)
Q.append(q / rjj)
return np.stack(Q, axis=0, like=X)