Ngoài các cấu trúc dữ liệu được mô tả ở trên, gói này cung cấp các phương pháp thống kê dựa trên khoảng cách sau
ví dụ
Tải ma trận khoảng cách 4x4 và nhóm vectơ biểu thị 2 nhóm đối tượng. Lưu ý rằng các phương pháp thống kê này yêu cầu khoảng cách đối xứng
>>> from skbio import DistanceMatrix >>> dm = DistanceMatrix[[[0, 1, 1, 4], .. [1, 0, 3, 2], .. [1, 3, 0, 3], .. [4, 2, 3, 0]], .. ['s1', 's2', 's3', 's4']] >>> grouping = ['Group1', 'Group1', 'Group2', 'Group2']
Tạo một phiên bản ANOSIM và chạy phương thức với 99 hoán vị
>>> import numpy as np
>>> np.random.seed[0] # Make output deterministic; not necessary for normal use
>>> from skbio.stats.distance import ANOSIM
>>> anosim = ANOSIM[dm, grouping]
>>> results = anosim[99]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.67 99
Có thể chạy lại một phương thức bằng một thể hiện hiện có. Chạy lại ANOSIM với 999 hoán vị lần này. Lưu ý rằng chúng tôi có được thống kê R giống như trước đây
>>> results = anosim[999]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.667 999
Để chặn tính toán giá trị p và chỉ thu được thống kê R, hãy chỉ định các hoán vị bằng 0
>>> results = anosim[0]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 N/A 0
Đối tượng kết quả thống kê cũng có thể định dạng kết quả của nó dưới dạng văn bản được phân tách. Điều này rất hữu ích, chẳng hạn như nếu bạn muốn xem kết quả trong chương trình bảng tính chẳng hạn như Excel
>>> print results.summary[delimiter=','] Method name,Sample size,Number of groups,R statistic,p-value,Number of permutations ANOSIM,4,2,0.25,N/A,0
Các giá trị riêng lẻ của kết quả có thể được truy cập thông qua các thuộc tính của lớp CategoricalStatsResults
>>> results.statistic 0.25 >>> print results.p_value None >>> results.permutations 0
Bạn cũng có thể cung cấp một pandas. DataFrame và một cột biểu thị nhóm thay vì một vectơ nhóm. Cột Nhóm của khung dữ liệu sau chỉ định nhóm giống như vectơ mà chúng tôi đã sử dụng trong tất cả các ví dụ trước
>>> np.random.seed[0] # Make output deterministic; not necessary for normal use
>>> import pandas as pd
>>> df = pd.DataFrame.from_dict[
.. {'Group': {'s2': 'Group1', 's3': 'Group2', 's4': 'Group2',
.. 's5': 'Group3', 's1': 'Group1'}}]
>>> anosim = ANOSIM[dm, df, column='Group']
>>> results = anosim[99]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.67 99
Kết quả khớp với kết quả chúng ta đã thấy trong ví dụ đầu tiên ở trên
Lưu ý rằng khi cung cấp khung dữ liệu, thứ tự của các hàng và/hoặc cột không ảnh hưởng đến vectơ nhóm được trích xuất. Khung dữ liệu phải được lập chỉ mục theo ID ma trận khoảng cách [i. e. , nhãn hàng phải là ID ma trận khoảng cách]
Nếu ID [hàng] có trong khung dữ liệu nhưng không có trong ma trận khoảng cách, thì chúng sẽ bị bỏ qua [ID s5 của ví dụ trước minh họa hành vi này]. Do đó, khung dữ liệu có thể là siêu tập hợp của ID ma trận khoảng cách. Lưu ý rằng điều ngược lại là không đúng. ID trong ma trận khoảng cách phải có trong khung dữ liệu nếu không sẽ xảy ra lỗi
Ma trận khoảng cách là một cấu trúc dữ liệu thực sự hữu ích lưu trữ thông tin theo cặp về cách các vectơ từ tập dữ liệu liên quan đến nhau. Trong học máy, chúng được sử dụng cho các nhiệm vụ như phân cụm cây phát sinh loài theo thứ bậc [xem xét tổ tiên di truyền] và trong các mô hình xử lý ngôn ngữ tự nhiên [NLP] để khám phá mối quan hệ giữa các từ [với các nhúng từ như Word2Vec, GloVe, fastText, v.v. ]. Ở đây, chúng ta sẽ xem xét ngắn gọn cách triển khai một hàm trong python có thể được sử dụng để tính toán hiệu quả khoảng cách theo cặp cho một tập hợp/hoặc tập hợp các vectơ
Nếu bạn muốn theo dõi, hãy kích hoạt iPython trong phiên cuối [hoặc tạo Notebook Jupyter mới]. Ngoài ra, hãy chắc chắn rằng bạn đã cài đặt gói Numpy
Sơ lược về khoảng cách Euclide
Nhớ lại rằng bình phương khoảng cách Euclide giữa hai vectơ a và b bất kỳ chỉ đơn giản là tổng bình phương các hiệu thành phần. [chúng tôi đang bỏ qua bước cuối cùng, lấy căn bậc hai, chỉ để làm cho các ví dụ dễ dàng]
Chúng ta có thể thực hiện tính toán này một cách ngây thơ với vanilla python như thế này
a = [i + 1 for i in range[0, 500]]
b = [i for i in range[0, 500]]
dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
dist_squared
500Trên thực tế, chúng ta có thể thực hiện tất cả các phép toán mà chúng ta sẽ làm theo cách này, nhưng nó sẽ chậm và tẻ nhạt. Numpy, thư viện số dứt khoát cho Python, cung cấp cho chúng tôi triển khai nhanh mọi thứ chúng tôi cần tại đây. Để minh họa lợi thế về tốc độ, hãy sử dụng các vectơ giống như mảng có nhiều mảng, thực hiện phép tính giống hệt nhau và sau đó thực hiện so sánh tốc độ với
>>> results = anosim[999]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.667 999
2________số 8
Như bạn có thể thấy, phiên bản Numpy nhanh hơn 20 lần so với triển khai ban đầu của chúng tôi
Có một công thức tương đương của khoảng cách Euclide bình phương cho các vectơ sử dụng tích
Hãy ghi nhớ điều này vì chúng tôi sẽ mở rộng công thức vectơ này thành ma trận trong triển khai ma trận khoảng cách cuối cùng của chúng tôi
Ma trận khoảng cách
Giả sử rằng chúng ta có một nhóm gồm ba quan sát trong đó mỗi quan sát là một vectơ có ba thành phần. Chúng ta có thể viết tập hợp các quan sát này dưới dạng ma trận A 3 x 3 trong đó mỗi hàng đại diện cho một quan sát
Ma trận khoảng cách cho A, mà chúng ta sẽ gọi là D, cũng là ma trận 3 x 3 trong đó mỗi phần tử trong ma trận biểu thị kết quả của phép tính khoảng cách cho hai trong số các hàng [vectơ] trong A. Lưu ý rằng D là đối xứng và có tất cả các số 0 trên đường chéo của nó. [Khoảng cách giữa một vectơ và chính nó bằng không]
Nếu tôi có hai nhóm quan sát mà tôi muốn so sánh khoảng cách thì sao? . Hãy giữ nguyên ma trận A đầu tiên của chúng ta và so sánh nó với ma trận B 2 x 3 mới. Ở đây, ma trận khoảng cách D mới của chúng tôi là 3 x 2. Nói chung, đối với bất kỳ ma trận khoảng cách nào giữa hai ma trận có kích thước M x K và N x K, kích thước của ma trận mới là M x N
Với phần lớn thông tin cơ bản được bao phủ, hãy nêu rõ vấn đề mà chúng ta muốn giải quyết. Chúng tôi muốn tạo một số hàm trong python sẽ lấy hai ma trận làm đối số và trả về một ma trận khoảng cách. Trong các ví dụ của chúng tôi, chúng tôi đã xem xét khoảng cách bình phương, vì vậy chúng tôi cũng sẽ thêm khả năng trả về khoảng cách bình phương nếu muốn
Thiết lập
Đầu tiên, hãy tạo các ma trận mẫu A và B từ trên để sử dụng làm dữ liệu thử nghiệm
A = np.array[[[1,2,3],[2,3,4],[0,1,2]]]
A
array[[[1, 2, 3],
[2, 3, 4],
[0, 1, 2]]]
B = np.array[[[1,2,3],[4,3,2]]]
B
array[[[1, 2, 3],
[4, 3, 2]]]Thực hiện
Bây giờ, hãy xem lại công thức khoảng cách thay thế ở trên và xem cách nó có thể được áp dụng cho hai ma trận A và B của chúng ta
Ma trận khoảng cách bên trái, mục tiêu của chúng ta, có thể được xây dựng từ ba ma trận tuân theo công thức trên. Hãy dành một chút thời gian để chắc chắn rằng bạn nhìn thấy mô hình. Bây giờ, hãy xây dựng ma trận tích vô hướng đầu tiên cho A
>>> import numpy as np
>>> np.random.seed[0] # Make output deterministic; not necessary for normal use
>>> from skbio.stats.distance import ANOSIM
>>> anosim = ANOSIM[dm, grouping]
>>> results = anosim[99]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.67 99
0Trước tiên, chúng tôi tìm số hàng
import numpy as np
a_numpy = np.array[a]
b_numpy = np.array[b]
dist_squared = np.sum[np.square[a_numpy - b_numpy]]
dist_squared
500
# using pure python
%timeit dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
119 µs ± 1.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
# using numpy
%timeit dist_squared = np.sum[np.square[a_numpy - b_numpy]]
6.32 µs ± 2.11 µs per loop [mean ± std. dev. of 7 runs, 100000 loops each]import numpy as np
a_numpy = np.array[a]
b_numpy = np.array[b]
dist_squared = np.sum[np.square[a_numpy - b_numpy]]
dist_squared
500
# using pure python
%timeit dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
119 µs ± 1.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
# using numpy
%timeit dist_squared = np.sum[np.square[a_numpy - b_numpy]]
6.32 µs ± 2.11 µs per loop [mean ± std. dev. of 7 runs, 100000 loops each]import numpy as np
a_numpy = np.array[a]
b_numpy = np.array[b]
dist_squared = np.sum[np.square[a_numpy - b_numpy]]
dist_squared
500
# using pure python
%timeit dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
119 µs ± 1.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
# using numpy
%timeit dist_squared = np.sum[np.square[a_numpy - b_numpy]]
6.32 µs ± 2.11 µs per loop [mean ± std. dev. of 7 runs, 100000 loops each]import numpy as np
a_numpy = np.array[a]
b_numpy = np.array[b]
dist_squared = np.sum[np.square[a_numpy - b_numpy]]
dist_squared
500
# using pure python
%timeit dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
119 µs ± 1.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
# using numpy
%timeit dist_squared = np.sum[np.square[a_numpy - b_numpy]]
6.32 µs ± 2.11 µs per loop [mean ± std. dev. of 7 runs, 100000 loops each]import numpy as np
a_numpy = np.array[a]
b_numpy = np.array[b]
dist_squared = np.sum[np.square[a_numpy - b_numpy]]
dist_squared
500
# using pure python
%timeit dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
119 µs ± 1.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
# using numpy
%timeit dist_squared = np.sum[np.square[a_numpy - b_numpy]]
6.32 µs ± 2.11 µs per loop [mean ± std. dev. of 7 runs, 100000 loops each]import numpy as np
a_numpy = np.array[a]
b_numpy = np.array[b]
dist_squared = np.sum[np.square[a_numpy - b_numpy]]
dist_squared
500
# using pure python
%timeit dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
119 µs ± 1.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
# using numpy
%timeit dist_squared = np.sum[np.square[a_numpy - b_numpy]]
6.32 µs ± 2.11 µs per loop [mean ± std. dev. of 7 runs, 100000 loops each]>>> import numpy as np
>>> np.random.seed[0] # Make output deterministic; not necessary for normal use
>>> from skbio.stats.distance import ANOSIM
>>> anosim = ANOSIM[dm, grouping]
>>> results = anosim[99]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.67 99
7Điều duy nhất cần lưu ý ở đây là trong ma trận B cuối cùng của chúng ta được biểu diễn trên các cột, vì vậy các tích vô hướng của chúng ta cũng được sắp xếp theo chiều cột. Ma trận cuối cùng của các sản phẩm chấm được xây dựng với
>>> import numpy as np
>>> np.random.seed[0] # Make output deterministic; not necessary for normal use
>>> from skbio.stats.distance import ANOSIM
>>> anosim = ANOSIM[dm, grouping]
>>> results = anosim[99]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.67 99
8Để tất cả chúng cùng nhau…
>>> import numpy as np
>>> np.random.seed[0] # Make output deterministic; not necessary for normal use
>>> from skbio.stats.distance import ANOSIM
>>> anosim = ANOSIM[dm, grouping]
>>> results = anosim[99]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.67 99
9chức năng cuối cùng
Và đây là mã được bao bọc trong một hàm với chuỗi tài liệu kiểu Numpy đẹp mắt
>>> results = anosim[999]
>>> print results
Method name Sample size Number of groups R statistic p-value Number of permutations
ANOSIM 4 2 0.25 0.667 999
0Phần kết luận
Và bạn có nó rồi đấy. Một chức năng hiệu quả để tính toán ma trận khoảng cách trong Python bằng Numpy. Trước khi chia tay bạn, tôi cần lưu ý rằng SciPy cũng có chức năng tích hợp sẵn [
import numpy as np
a_numpy = np.array[a]
b_numpy = np.array[b]
dist_squared = np.sum[np.square[a_numpy - b_numpy]]
dist_squared
500
# using pure python
%timeit dist_squared = sum[[[a_i - b_i]**2 for a_i, b_i in zip[a, b]]]
119 µs ± 1.02 µs per loop [mean ± std. dev. of 7 runs, 10000 loops each]
# using numpy
%timeit dist_squared = np.sum[np.square[a_numpy - b_numpy]]
6.32 µs ± 2.11 µs per loop [mean ± std. dev. of 7 runs, 100000 loops each]