在 python 中使组合更快

Question

我想生成 NN 大小的矩阵的大小从 3 到 N-2 的不同组合。对于超过 10 个尺寸的矩阵，该过程需要很长时间。请指导我如何更快地生成大小为 5050 的矩阵的组合。 更多说明的代码如下。

def ProduceAllPossibleCombinationsDictionary(CurrentNetworkMatrix, number_of_combinations):
    # find all possible combinations
    num_combination=number_of_combinations
    test_list= CurrentNetworkMatrix.columns

    for j in range(len(list(combinations(test_list, num_combination)))):
        controllability_combination_mean ={}

        key=list(combinations(test_list, num_combination))[j]
        Mat=CurrentNetworkMatrix.loc[key,key]
        #produce symmetric connectivity matrix
        Adj=np.triu(Mat, k=1)
        adj=Adj+Adj.transpose()
        netss=pd.DataFrame(adj, columns=Mat.columns, index=Mat.columns)
        # sum of connections between nodes of network
        m=np.sum(netss)
        a=np.mean(netss)
        dd11= pd.concat([pd.DataFrame(a, columns=['mean']),
                        pd.DataFrame(m, columns=['sum'])],
                       join = 'outer', axis = 1)
        for i in range(num_combination):
    #     # append all possible cases:
            c_combination_mean[key[i]]=(key, dd11.iloc[i,0])
        test.append(c_combination_mean)

    AllPossibleCombinationsDictionary=test
    return AllPossibleCombinationsDictionary

我尝试过小尺寸的矩阵，还可以，但是对于大尺寸的矩阵，例如50*50，需要超过3天，并且没有显示结果。

Answer 1

这是函数的修改版本：

from itertools import combinations
import numpy as np
import pandas as pd

def produce_all_possible_combinations_dictionary(CurrentNetworkMatrix, number_of_combinations):
    num_combination = number_of_combinations
    test_list = list(CurrentNetworkMatrix.columns)
    all_possible_combinations = []

    for key in combinations(test_list, num_combination):
        key = tuple(sorted(key))  # Ensure consistent ordering for symmetric matrices
        Mat = CurrentNetworkMatrix.loc[key, key]
        adj = np.triu(Mat.values, k=1) + np.triu(Mat.values, k=1).T  # Symmetric adjacency matrix
        netss = pd.DataFrame(adj, columns=Mat.columns, index=Mat.columns)
        m = np.sum(netss)
        a = np.mean(netss)
        dd11 = pd.DataFrame({'mean': a, 'sum': m})

        c_combination_mean = {key[i]: (key, dd11.iloc[i, 0]) for i in range(num_combination)}
        all_possible_combinations.append(c_combination_mean)

    return all_possible_combinations

# Example usage:
# Define the size of the matrix
matrix_size = 50

# Generate a random symmetric matrix
data = np.random.rand(matrix_size, matrix_size)
symmetric_data = np.triu(data) + np.triu(data, k=1).T

# Create a DataFrame from the symmetric matrix
network_matrix = pd.DataFrame(symmetric_data, columns=range(matrix_size), index=range(matrix_size))

# Define the number of combinations you want to generate
number_of_combinations = 3

# Call the function to produce combinations
result = produce_all_possible_combinations_dictionary(network_matrix, number_of_combinations)
# Example output: printing the first few combinations
for idx, combination in enumerate(result[:5]):
    print(f"Combination {idx+1}:")
    for node, values in combination.items():
        print(f"Node: {node}, Mean: {values[0]}, Sum: {values[1]}")
    print()

请记住，较大的矩阵将需要更多时间来处理。