Tối ưu hóa tính toán khoảng cách Python trong khi tính toán các điều kiện biên định kỳ

Question

Tôi đã viết một kịch bản Python để tính toán khoảng cách giữa hai điểm trong không gian 3D trong khi tính toán các điều kiện biên định kỳ. Vấn đề là tôi cần thực hiện phép tính này cho nhiều, nhiều điểm và tính toán khá chậm. Đây là chức năng của tôi.

def PBCdist(coord1,coord2,UC): 
    dx = coord1[0] - coord2[0] 
    if (abs(dx) > UC[0]*0.5): 
     dx = UC[0] - dx 
    dy = coord1[1] - coord2[1] 
    if (abs(dy) > UC[1]*0.5): 
     dy = UC[1] - dy 
    dz = coord1[2] - coord2[2] 
    if (abs(dz) > UC[2]*0.5): 
     dz = UC[2] - dz 
    dist = np.sqrt(dx**2 + dy**2 + dz**2) 
    return dist 

sau đó tôi gọi hàm như vậy

for i, coord2 in enumerate(coordlist): 
    if (PBCdist(coord1,coord2,UC) < radius): 
     do something with i 

Gần đây tôi đọc mà tôi có thể làm tăng đáng kể hiệu suất bằng cách sử dụng danh sách hiểu. Các công trình sau đây không áp dụng cho trường hợp không thuộc PBC, nhưng không áp dụng cho trường hợp PBC

coord_indices = [i for i, y in enumerate([np.sqrt(np.sum((coord2-coord1)**2)) for coord2 in coordlist]) if y < radius] 
for i in coord_indices: 
    do something 

Có cách nào để thực hiện tương đương với trường hợp PBC không? Có một giải pháp thay thế nào có hiệu quả hơn không?

Answer 1

Bạn nên viết của bạn distance() chức năng theo cách bạn có thể vectơ vòng lặp trên 5711 điểm. Việc thực hiện sau đây chấp nhận một loạt các điểm như một trong hai x0 hoặc x1 tham số:

def distance(x0, x1, dimensions): 
    delta = numpy.abs(x0 - x1) 
    delta = numpy.where(delta > 0.5 * dimensions, delta - dimensions, delta) 
    return numpy.sqrt((delta ** 2).sum(axis=-1)) 

Ví dụ:

>>> dimensions = numpy.array([3.0, 4.0, 5.0]) 
>>> points = numpy.array([[2.7, 1.5, 4.3], [1.2, 0.3, 4.2]]) 
>>> distance(points, [1.5, 2.0, 2.5], dimensions) 
array([ 2.22036033, 2.42280829]) 

Kết quả là hàng loạt các khoảng cách giữa các điểm thông qua như là tham số thứ hai để distance() và mỗi điểm trong points.

Answer 2

Hãy xem Ian Ozsvalds high performance python tutorial. Nó chứa rất nhiều gợi ý về nơi bạn có thể tiếp theo.

Bao gồm:

• vector hóa
• cython
• PyPy
• numexpr
• pycuda
• multiprocesing
• python song song

Answer 3

import numpy as np 

bounds = np.array([10, 10, 10]) 
a = np.array([[0, 3, 9], [1, 1, 1]]) 
b = np.array([[2, 9, 1], [5, 6, 7]]) 

min_dists = np.min(np.dstack(((a - b) % bounds, (b - a) % bounds)), axis = 2) 
dists = np.sqrt(np.sum(min_dists ** 2, axis = 1)) 

Đây a và b là danh sách các vectơ bạn muốn để tính toán khoảng cách giữa và bounds là ranh giới của không gian (vì vậy ở đây cả ba chiều đi 0-10 và sau đó quấn). Nó tính toán khoảng cách giữa a[0] và b[0], a[1] và b[1], v.v.

tôi chắc chắn rằng các chuyên gia NumPy có thể làm tốt hơn, nhưng điều này có lẽ sẽ là một thứ tự cường độ nhanh hơn so với những gì bạn đang làm, vì hầu hết các công việc đang thực hiện trong C.

Answer 4

Tôi thấy rằng meshgrid rất hữu ích trong việc tạo khoảng cách.Ví dụ:

import numpy as np 
row_diff, col_diff = np.meshgrid(range(7), range(8)) 
radius_squared = (row_diff - x_coord)**2 + (col_diff - y_coord)**2 

bây giờ tôi có một mảng (radius_squared), nơi tất cả các mục quy định các bình phương khoảng cách từ vị trí mảng [x_coord, y_coord].

Để gởi thông tư mảng, tôi có thể làm như sau:

row_diff, col_diff = np.meshgrid(range(7), range(8)) 
row_diff = np.abs(row_diff - x_coord) 
row_circ_idx = np.where(row_diff > row_diff.shape[1]/2) 
row_diff[row_circ_idx] = (row_diff[row_circ_idx] - 
         2 * (row_circ_idx + x_coord) + 
         row_diff.shape[1]) 
row_diff = np.abs(row_diff) 
col_diff = np.abs(col_diff - y_coord) 
col_circ_idx = np.where(col_diff > col_diff.shape[0]/2) 
col_diff[row_circ_idx] = (row_diff[col_circ_idx] - 
         2 * (col_circ_idx + y_coord) + 
         col_diff.shape[0]) 
col_diff = np.abs(row_diff) 
circular_radius_squared = (row_diff - x_coord)**2 + (col_diff - y_coord)**2 

bây giờ tôi có tất cả các khoảng cách mảng circularized với toán vectơ.