Hướng dẫn how does python handle sparse matrix? - python xử lý ma trận thưa thớt như thế nào?

Gói mảng thưa thớt Scipy 2-D cho dữ liệu số.

Ghi chú

Gói này đang chuyển sang giao diện mảng, tương thích với các mảng numpy, từ giao diện ma trận cũ hơn. Chúng tôi khuyên bạn nên sử dụng các đối tượng mảng [bsr_array,

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

0, v.v.] cho tất cả các công việc mới.

Khi sử dụng giao diện mảng, xin lưu ý rằng:

```
>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]
```
1 không còn thực hiện phép nhân ma trận, mà là phép nhân theo phần tử [giống như với các mảng numpy]. Để làm cho mã hoạt động với cả mảng và ma trận, hãy sử dụng
```
>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]
```
2 để nhân ma trận.
Các hoạt động như tổng, được sử dụng để tạo ra các ma trận dày đặc, hiện tạo ra các mảng, có hành vi nhân khác nhau khác nhau.
Mảng thưa thớt hiện phải có hai chiều. Điều này cũng có nghĩa là tất cả các hoạt động cắt trên các đối tượng này phải tạo ra kết quả hai chiều hoặc chúng sẽ dẫn đến lỗi. Điều này sẽ được giải quyết trong một phiên bản trong tương lai.

Các tiện ích xây dựng [

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

6, v.v.] vẫn chưa được chuyển, nhưng kết quả của chúng có thể được gói thành các mảng:

Contents#

Các lớp mảng thưa thớt#

`bsr_array`[arg1[, shape, dtype, copy, blocksize]]	Khối mảng hàng thưa thớt
>>> np.dot[A.toarray[], v] array[[ 1, -3, -1], dtype=int64] 0[arg1[, shape, dtype, copy]]	Một mảng thưa thớt ở định dạng tọa độ.
>>> np.dot[A.toarray[], v] array[[ 1, -3, -1], dtype=int64] 9[arg1[, shape, dtype, copy]]	Mảng cột thưa thớt nén
>>> from scipy.sparse import lil_matrix >>> from scipy.sparse.linalg import spsolve >>> from numpy.linalg import solve, norm >>> from numpy.random import rand 0[arg1[, shape, dtype, copy]]	Mảng hàng thưa thớt nén
>>> from scipy.sparse import lil_matrix >>> from scipy.sparse.linalg import spsolve >>> from numpy.linalg import solve, norm >>> from numpy.random import rand 1[arg1[, shape, dtype, copy]]	Mảng thưa thớt với lưu trữ đường chéo
>>> from scipy.sparse import lil_matrix >>> from scipy.sparse.linalg import spsolve >>> from numpy.linalg import solve, norm >>> from numpy.random import rand 2[arg1[, shape, dtype, copy]]	Từ điển của mảng thưa thớt dựa trên chìa khóa.
>>> from scipy.sparse import lil_matrix >>> from scipy.sparse.linalg import spsolve >>> from numpy.linalg import solve, norm >>> from numpy.random import rand 3[arg1[, shape, dtype, copy]]	Danh sách danh sách dựa trên hàng

Các lớp ma trận thưa thớt#

>>> from scipy.sparse import lil_matrix
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

4[arg1[, shape, dtype, copy, blocksize]]

Chặn ma trận hàng thưa thớt

>>> from scipy.sparse import lil_matrix
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

5[arg1[, shape, dtype, copy]]

Một ma trận thưa thớt ở định dạng tọa độ.

>>> from scipy.sparse import lil_matrix
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

6[arg1[, shape, dtype, copy]]

Ma trận cột thưa thớt nén

>>> from scipy.sparse import lil_matrix
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

7[arg1[, shape, dtype, copy]]

Ma trận hàng thưa thớt nén

>>> from scipy.sparse import lil_matrix
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

8[arg1[, shape, dtype, copy]]

Ma trận thưa thớt với lưu trữ đường chéo

>>> from scipy.sparse import lil_matrix
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

9[arg1[, shape, dtype, copy]]

Từ điển của ma trận thưa thớt dựa trên chìa khóa.

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

0[arg1[, shape, dtype, copy]]

Danh sách danh sách dựa trên hàng Ma trận thưa thớt

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

1[[maxprint]]

Lớp này cung cấp một lớp cơ sở cho tất cả các ma trận thưa thớt.

Functions#

Xây dựng ma trận thưa thớt:

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

3[m[, n, k, dtype, format]]

Ma trận thưa thớt với các con đường chéo

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

3[n[, dtype, format]]

Ma trận nhận dạng ở định dạng thưa thớt

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

4[A, B[, format]]

sản phẩm kronecker của ma trận thưa thớt a và b

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

5[A, B[, format]]

tổng hợp kronecker của ma trận thưa thớt a và b

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

6[diagonals[, offsets, shape, format, dtype]]

Xây dựng một ma trận thưa thớt từ các đường chéo.

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

7[data, diags[, m, n, format]]

Trả về một ma trận thưa thớt từ các đường chéo.

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

8[mats[, format, dtype]]

Xây dựng một ma trận thưa thớt đường chéo từ các ma trận được cung cấp.

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

9[A[, k, format]]

Trả về phần hình tam giác thấp hơn của ma trận ở định dạng thưa thớt

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

0[A[, k, format]]

Trả về phần hình tam giác phía trên của ma trận ở định dạng thưa thớt

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

1[blocks[, format, dtype]]

Xây dựng một ma trận thưa thớt từ các khối phụ thưa thớt

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

2[blocks[, format, dtype]]

Stack Ma trận thưa thớt theo chiều ngang [cột khôn ngoan]

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

3[blocks[, format, dtype]]

Stack Ma trận thưa thớt theo chiều dọc [hàng khôn ngoan]

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

4[m, n[, density, format, dtype, ...]]

Tạo một ma trận thưa thớt của hình dạng và mật độ đã cho với các giá trị phân phối đồng đều.

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

5[m, n[, density, format, dtype, ...]]

Tạo một ma trận thưa thớt của hình dạng và mật độ đã cho với các giá trị phân phối ngẫu nhiên.

Lưu và tải ma trận thưa thớt:

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

6[file, matrix[, compressed]]

Lưu ma trận thưa thớt vào một tệp bằng định dạng

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

8[file]

Tải một ma trận thưa thớt từ một tệp bằng định dạng

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

Công cụ ma trận thưa thớt:

>>> x_ = solve[A.toarray[], b]

0[A]

Trả về các chỉ số và giá trị của các phần tử khác của ma trận

Xác định ma trận thưa thớt:

>>> x_ = solve[A.toarray[], b]

1[x]

X có phải là loại ma trận thưa thớt không?

>>> x_ = solve[A.toarray[], b]

2[x]

X có phải là loại ma trận thưa thớt không?

>>> x_ = solve[A.toarray[], b]

3[x]

X của CSC_Matrix có phải là loại không?

>>> x_ = solve[A.toarray[], b]

4[x]

X của loại csr_matrix có phải là không?

>>> x_ = solve[A.toarray[], b]

5[x]

X có phải là loại BSR_Matrix không?

>>> x_ = solve[A.toarray[], b]

6[x]

X của lil_matrix loại?

>>> x_ = solve[A.toarray[], b]

7[x]

X của DOK_MATRIX có phải là loại không?

>>> x_ = solve[A.toarray[], b]

8[x]

X của COO_Matrix có phải là loại không?

>>> x_ = solve[A.toarray[], b]

9[x]

X của Dia_Matrix có phải là loại không?

Submodules#

>>> err = norm[x-x_]
>>> err >> err = norm[x-x_]
>>> err >> err = norm[x-x_]
>>> err >> err = norm[x-x_]
>>> err >> import numpy as np
>>> from scipy.sparse import csr_matrix
>>> A = csr_matrix[[[1, 2, 0], [0, 0, 3], [4, 0, 5]]]
>>> v = np.array[[1, 0, -1]]
>>> A.dot[v]
array[[ 1, -3, -1], dtype=int64]

Cảnh báo

Kể từ Numpy 1.7, NP.DOT không biết về ma trận thưa thớt, do đó sử dụng nó sẽ dẫn đến kết quả hoặc lỗi không mong muốn. Thay vào đó, mảng dày đặc tương ứng phải được lấy trước tiên: thay vào đó:

>>> np.dot[A.toarray[], v]
array[[ 1, -3, -1], dtype=int64]

Nhưng sau đó tất cả các lợi thế hiệu suất sẽ bị mất.

Định dạng CSR đặc biệt phù hợp cho các sản phẩm vector ma trận nhanh.

Ví dụ 1#

Xây dựng 1000x1000 lil_matrix và thêm một số giá trị vào nó:

>>> from scipy.sparse import lil_matrix
>>> from scipy.sparse.linalg import spsolve
>>> from numpy.linalg import solve, norm
>>> from numpy.random import rand

>>> A = lil_matrix[[1000, 1000]]
>>> A[0, :100] = rand[100]
>>> A[1, 100:200] = A[0, :100]
>>> A.setdiag[rand[1000]]

Bây giờ hãy chuyển đổi nó thành định dạng CSR và giải A x = B cho x:

>>> A = A.tocsr[]
>>> b = rand[1000]
>>> x = spsolve[A, b]

Chuyển đổi nó thành một ma trận dày đặc và giải quyết, và kiểm tra xem kết quả có giống nhau không:

>>> x_ = solve[A.toarray[], b]

Bây giờ chúng ta có thể tính toán định mức của lỗi với:

>>> err = norm[x-x_]
>>> err >> from scipy import sparse
>>> from numpy import array
>>> I = array[[0,3,1,0]]
>>> J = array[[0,3,1,2]]
>>> V = array[[4,5,7,9]]
>>> A = sparse.coo_matrix[[V,[I,J]],shape=[4,4]]

Lưu ý rằng các chỉ số không cần phải được sắp xếp.

Các mục trùng lặp [i, j] được tổng hợp khi chuyển đổi sang CSR hoặc CSC.

>>> I = array[[0,0,1,3,1,0,0]]
>>> J = array[[0,2,1,3,1,0,0]]
>>> V = array[[1,1,1,1,1,1,1]]
>>> B = sparse.coo_matrix[[V,[I,J]],shape=[4,4]].tocsr[]

Điều này rất hữu ích cho việc xây dựng độ cứng nguyên tố hữu hạn và ma trận khối lượng.

Biết thêm chi tiết#

Chỉ số cột CSR không nhất thiết phải được sắp xếp. Tương tự như vậy đối với các chỉ số hàng CSC. Sử dụng các phương thức .sorted_indices [] và .sort_indices [] khi các chỉ số được sắp xếp được yêu cầu [ví dụ: khi chuyển dữ liệu cho các thư viện khác].

Làm thế nào để Python đối phó với ma trận thưa thớt?

Đại diện cho một ma trận thưa thớt bằng một mảng 2D dẫn đến sự lãng phí của nhiều bộ nhớ vì các số 0 trong ma trận không được sử dụng trong hầu hết các trường hợp. Vì vậy, thay vì lưu trữ số 0 với các phần tử khác không, chúng tôi chỉ lưu trữ các yếu tố khác không. Điều này có nghĩa là lưu trữ các phần tử khác không với bộ ba- [hàng, cột, giá trị].instead of storing zeroes with non-zero elements, we only store non-zero elements. This means storing non-zero elements with triples- [Row, Column, value].

Làm thế nào để bạn lưu trữ một ma trận thưa thớt trong Python?

Lưu ma trận thưa thớt vào tệp bằng định dạng .npz.Tên tệp [chuỗi] hoặc một tệp mở [đối tượng giống như tệp] nơi dữ liệu sẽ được lưu. npz format. Either the file name [string] or an open file [file-like object] where the data will be saved.

Làm thế nào để bạn xử lý ma trận thưa thớt?

Giải pháp để biểu diễn và làm việc với ma trận thưa thớt là sử dụng cấu trúc dữ liệu thay thế để thể hiện dữ liệu thưa thớt.Các giá trị bằng không có thể được bỏ qua và chỉ các giá trị dữ liệu hoặc không khác trong ma trận thưa thớt cần được lưu trữ hoặc hoạt động.use an alternate data structure to represent the sparse data. The zero values can be ignored and only the data or non-zero values in the sparse matrix need to be stored or acted upon.

Làm thế nào để máy học xử lý dữ liệu thưa thớt?

Phương pháp đối phó với các tính năng thưa thớt..

Loại bỏ các tính năng khỏi mô hình.Các tính năng thưa thớt có thể giới thiệu tiếng ồn, mô hình nhận được và tăng nhu cầu bộ nhớ của mô hình.....

Làm cho các tính năng dày đặc.....

Sử dụng các mô hình mạnh mẽ để các tính năng thưa thớt ..