svd | Python code implementing the power method | Machine Learning library

M is a np.matrix, which are always 2-D (so it has two dimensions). As the error message indicates, you can only use a 0- or 1-D array when assigning to an array masked with a boolean mask (which is what you're doing).

Instead, convert M to an array first (which, as @hpaulj pointed out, is better than using asarray + ravel)

Please follow the post for the clear answer, https://forums.developer.nvidia.com/t/eigen-decomposition-of-hermitian-matrix-using-cusolver-does-not-match-the-result-with-matlab/204157

The theory tells, A*V-lamda*V=0 should satisfy, however it might not be perfect zero. My thinking was it will very very close to zero or e-14 somethng like this. If the equation gives a value close to zero then it is acceptable.

There are different algorithms for solving eigen decomposition, like Jacobi algorithm, Cholesky factorization... The program I provided in my post uses the function cusolverDnCheevd which is based on LAPACK. LAPACK doc tells that it uses divide and conquer algorithm to solve Hermitian matrix. Here is the link, http://www.netlib.org/lapack/explore-html/d9/de3/group__complex_h_eeigen_ga6084b0819f9642f0db26257e8a3ebd42.html#ga6084b0819f9642f0db26257e8a3ebd42

Not a perfect solution, I must admit. But it's simple and comes pretty close.
I create 5 vectors that are gonna span the space of the matrix and create random linear combinations to fill the rest of the matrix. My initial thought was that a trivial solution will be to copy those vectors 20 times.
To improve that, I created linear combinations of them with weights drawn from a uniform distribution, but then the distribution of the entries in the matrix becomes normal because the weighted mean basically causes the central limit theorm to take effect.
A middle point between the trivial approach and the second approach that doesn't work is to use sets of weights that favor one of the vectors over the others. And you can generate these sorts of weight vectors by passing any vector through the softmax function with an appropriately high temperature parameter.
The distribution is almost uniform, but the vectors are still very close to the base vectors. You can play with the temperature parameter to find a sweet spot that suits your purpose.

The problem lies in this line of code modes <- as.data.frame(svd.result$u). In order to convert the results back to a 3D array, you need modes to actually be a matrix rather than a dataframe. Your code should work if you simply change it to modes <- svd.result$u.

It seems like your dat file uses Shift JIS(Japanese) encoding. So you can pass shift_jis as the encoding argument to the open function.

It is usually written wiki, where V* is the transpose of V:

And this is what you get back in scipy.linalg.svd:

Factorizes the matrix a into two unitary matrices U and Vh, and a 1-D array s of singular values (real, non-negative) such that a == U @ S @ Vh, where S is a suitably shaped matrix of zeros with main diagonal s.

Whereas for svd in R they return you V. Therefore should be:

I'm not certain this fixes your issue, but you don't need to loop anything because np.linalg.svd() already handles n-dimensional arrays. (Even if it didn't, you basically never need loops in NumPy.)

This is how I'd do what you're doing:

From the help page for scaler :

with_mean bool, default=True If True, center the data before scaling. This does not work (and will raise an exception) when attempted on sparse matrices, because centering them entails building a dense matrix which in common use cases is likely to be too large to fit in memory.

For PCA and SVD to give the same output, you need to center and scale the data, see also this post for details, so if you do:

Looks like prebuilt UE4 doesn't include the "compiled" Eigen headers ("Dense", "Sparse", etc.), though it does include the Eigen "src" folder.

If you compile your Engine from source, you should have a complete Eigen install in the ThirdParty folder. You can then use that just like various Engine plugins do. But compiling Unreal from source is a bit of a pain and takes a lot of hard drive space. This would also prevent you from distributing your plugin in source form, as normal users wouldn't have Eigen available.

It's probably easiest to include a local copy of Eigen with your plugin - it's just headers, so you can include it with just a private include path in the build.cs.