w**w
发帖数: 100 | 1 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
size(A) = 50000, 50000
size(b) = 60000, 50000
matlab: x = b/A
用了 20 分钟，内存最多时居然用了 75G
python:
xx = scipy.sparse.linalg.splu(A)
xx_inv = xx.solve(np.eye(A.shape[0]))
x = b*xx_inv.T
同样用了很大内存，算了很久还没完，杀了。
有什么好的算法， 快 还少占内存？
多谢 |
n******i
发帖数: 118 | 2 Matlab 把A,B存成sparse matrix呢 |
n****e
发帖数: 2401 | |
M****e
发帖数: 3715 | 4 把b拆成列向量 每个单独用迭代
sparse矩阵的线性方程迭代算法wiki上有应该介绍一些吧
【在 w**w 的大作中提到】
: 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
: size(A) = 50000, 50000
: size(b) = 60000, 50000
: matlab: x = b/A
: 用了 20 分钟，内存最多时居然用了 75G
: python:
: xx = scipy.sparse.linalg.splu(A)
: xx_inv = xx.solve(np.eye(A.shape[0]))
: x = b*xx_inv.T
: 同样用了很大内存，算了很久还没完，杀了。
|
h*******5
发帖数: 59 | 5 你听过iterative methods 么？ 看看Matlab里的 pcg 函数。
BTW，你Matlab程序写错了，应该是x=A\b而不是 b/A. 你这样做用的是高斯消元法，比
较慢。 |
S****8
发帖数: 401 | 6 楼上正解，非要用matlab的先试试LU
然后找找matlab下的 iterative routine.
其实你这个并不算很大的运算，再大一些就得用fortran，c神马的并行算，可以去参考
SLEPC 这个
library， 用起来略麻烦， lapack里面有些东西已经老啦。
你这个size，我觉得用matlab足够，我经常用pc算这个量级的运算，解一次不需要一分
钟，当然，取决于稀松的程度和形状 |
d**0
发帖数: 124 | 7 precondioning on A
【在 w**w 的大作中提到】
: 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
: size(A) = 50000, 50000
: size(b) = 60000, 50000
: matlab: x = b/A
: 用了 20 分钟，内存最多时居然用了 75G
: python:
: xx = scipy.sparse.linalg.splu(A)
: xx_inv = xx.solve(np.eye(A.shape[0]))
: x = b*xx_inv.T
: 同样用了很大内存，算了很久还没完，杀了。
|
H***a
发帖数: 735 | 8 matrix b 的 size 怎么会是60000 ？
【在 w**w 的大作中提到】
: 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
: size(A) = 50000, 50000
: size(b) = 60000, 50000
: matlab: x = b/A
: 用了 20 分钟，内存最多时居然用了 75G
: python:
: xx = scipy.sparse.linalg.splu(A)
: xx_inv = xx.solve(np.eye(A.shape[0]))
: x = b*xx_inv.T
: 同样用了很大内存，算了很久还没完，杀了。
|
w**w
发帖数: 100 | 9 Ax = b 如果b 只是一列向量， 那一下就解出来了，还不占什么内存。
但不至于循环 50000 次吧， 这样虽然没有内存问题，但很慢。
【在 M****e 的大作中提到】
: 把b拆成列向量 每个单独用迭代
: sparse矩阵的线性方程迭代算法wiki上有应该介绍一些吧
|
w**w
发帖数: 100 | 10 如果 A 是对称 的呢？
对称 正定 呢 ？
谢谢
【在 d**0 的大作中提到】
: precondioning on A
|
|
|
w**w
发帖数: 100 | 11 oh, 反了。
【在 H***a 的大作中提到】
: matrix b 的 size 怎么会是60000 ？
|
w**w
发帖数: 100 | 12 等我确定 A 是 不是 对称正定。。。 再试试这个。
多谢
【在 h*******5 的大作中提到】
: 你听过iterative methods 么？ 看看Matlab里的 pcg 函数。
: BTW，你Matlab程序写错了，应该是x=A\b而不是 b/A. 你这样做用的是高斯消元法，比
: 较慢。
|
f*******a
发帖数: 663 | 13 Incomplete Cholesky Conjugate Gradients
【在 w**w 的大作中提到】
: 如果 A 是对称 的呢？
: 对称 正定 呢 ？
: 谢谢
|
e*******l
发帖数: 147 | |
s******i
发帖数: 132 | |
s*d
发帖数: 309 | |
f**x
发帖数: 4325 | |
w**w
发帖数: 100 | 18 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
size(A) = 50000, 50000
size(b) = 60000, 50000
matlab: x = b/A
用了 20 分钟，内存最多时居然用了 75G
python:
xx = scipy.sparse.linalg.splu(A)
xx_inv = xx.solve(np.eye(A.shape[0]))
x = b*xx_inv.T
同样用了很大内存，算了很久还没完，杀了。
有什么好的算法， 快 还少占内存？
多谢 |
n******i
发帖数: 118 | 19 Matlab 把A,B存成sparse matrix呢 |
n****e
发帖数: 2401 | |
|
|
M****e
发帖数: 3715 | 21 把b拆成列向量 每个单独用迭代
sparse矩阵的线性方程迭代算法wiki上有应该介绍一些吧
【在 w**w 的大作中提到】
: 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
: size(A) = 50000, 50000
: size(b) = 60000, 50000
: matlab: x = b/A
: 用了 20 分钟，内存最多时居然用了 75G
: python:
: xx = scipy.sparse.linalg.splu(A)
: xx_inv = xx.solve(np.eye(A.shape[0]))
: x = b*xx_inv.T
: 同样用了很大内存，算了很久还没完，杀了。
|
h*******5
发帖数: 59 | 22 你听过iterative methods 么？ 看看Matlab里的 pcg 函数。
BTW，你Matlab程序写错了，应该是x=A\b而不是 b/A. 你这样做用的是高斯消元法，比
较慢。 |
S****8
发帖数: 401 | 23 楼上正解，非要用matlab的先试试LU
然后找找matlab下的 iterative routine.
其实你这个并不算很大的运算，再大一些就得用fortran，c神马的并行算，可以去参考
SLEPC 这个
library， 用起来略麻烦， lapack里面有些东西已经老啦。
你这个size，我觉得用matlab足够，我经常用pc算这个量级的运算，解一次不需要一分
钟，当然，取决于稀松的程度和形状 |
d**0
发帖数: 124 | 24 precondioning on A
【在 w**w 的大作中提到】
: 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
: size(A) = 50000, 50000
: size(b) = 60000, 50000
: matlab: x = b/A
: 用了 20 分钟，内存最多时居然用了 75G
: python:
: xx = scipy.sparse.linalg.splu(A)
: xx_inv = xx.solve(np.eye(A.shape[0]))
: x = b*xx_inv.T
: 同样用了很大内存，算了很久还没完，杀了。
|
H***a
发帖数: 735 | 25 matrix b 的 size 怎么会是60000 ？
【在 w**w 的大作中提到】
: 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
: size(A) = 50000, 50000
: size(b) = 60000, 50000
: matlab: x = b/A
: 用了 20 分钟，内存最多时居然用了 75G
: python:
: xx = scipy.sparse.linalg.splu(A)
: xx_inv = xx.solve(np.eye(A.shape[0]))
: x = b*xx_inv.T
: 同样用了很大内存，算了很久还没完，杀了。
|
w**w
发帖数: 100 | 26 Ax = b 如果b 只是一列向量， 那一下就解出来了，还不占什么内存。
但不至于循环 50000 次吧， 这样虽然没有内存问题，但很慢。
【在 M****e 的大作中提到】
: 把b拆成列向量 每个单独用迭代
: sparse矩阵的线性方程迭代算法wiki上有应该介绍一些吧
|
w**w
发帖数: 100 | 27 如果 A 是对称 的呢？
对称 正定 呢 ？
谢谢
【在 d**0 的大作中提到】
: precondioning on A
|
w**w
发帖数: 100 | 28 oh, 反了。
【在 H***a 的大作中提到】
: matrix b 的 size 怎么会是60000 ？
|
w**w
发帖数: 100 | 29 等我确定 A 是 不是 对称正定。。。 再试试这个。
多谢
【在 h*******5 的大作中提到】
: 你听过iterative methods 么？ 看看Matlab里的 pcg 函数。
: BTW，你Matlab程序写错了，应该是x=A\b而不是 b/A. 你这样做用的是高斯消元法，比
: 较慢。
|
f*******a
发帖数: 663 | 30 Incomplete Cholesky Conjugate Gradients
【在 w**w 的大作中提到】
: 如果 A 是对称 的呢？
: 对称 正定 呢 ？
: 谢谢
|
|
|
e*******l
发帖数: 147 | |
s******i
发帖数: 132 | |
s*d
发帖数: 309 | |
f**x
发帖数: 4325 | |
a*******g
发帖数: 3500 | |
K******C
发帖数: 230 | 36 svd.
【在 w**w 的大作中提到】
: 需要解个方程 AX = b， A b 都是稀疏矩阵, 比较大。
: size(A) = 50000, 50000
: size(b) = 60000, 50000
: matlab: x = b/A
: 用了 20 分钟，内存最多时居然用了 75G
: python:
: xx = scipy.sparse.linalg.splu(A)
: xx_inv = xx.solve(np.eye(A.shape[0]))
: x = b*xx_inv.T
: 同样用了很大内存，算了很久还没完，杀了。
|
y********e
发帖数: 93 | 37 if it's positive-definite, matlab will solve it using Cholesky factorization
, which is fast. If not, it will use LU decomposition, which is slow.
If the performance is really an issue and you really want to optimize it,
try using parallel iterative solver implemented in CUDA. It will improve
your performance by a factor at a cost within $1k.
There are two or three existing CUDA linear solver package out there for
free. Try google it and compile them. |
