python - 如何根据子列表 [0] 中的模式加速划分子列表列表的过程？

Question

我有 2 个整数列表和稀疏矩阵:
list_index = [1,1,2,3,3,4,4,5] 和
matrix_user = [sparse1, sparse2, sparse3, sparse4, sparse5, sparse6]

我想要一个子列表列表，每个子列表由一个 int 列表和一个稀疏矩阵组成:

[ [[1,1,2,3,3], [sparse1, sparse2, sparse3, sparse4]] ,
  [[4,4,5],     [sparse5, sparse6]] ,
  ... ,
  ]

长度约为 90(稍后将并行运行)，每个 sublist[0] 包含非重叠值。

为了将 2 个输入列表切割成 90 个部分，我执行以下操作:

# cut the data into chunk to run in parallel
list_index  = dfuser['idx'].tolist()
matrix_user = encoder.fit_transform(dfuser[['col1','col2']].values)
sizechunk   = 90
sizelist    = int(len(list_index)/sizechunk)
if len(list_index)%sizechunk!=0 : sizelist += 1

list_all = []
for i in range(sizechunk) :
    if i*sizelist > len(list_index) : continue
    if (i+1)*sizelist < len(list_index) : list_all.append(  [list_index[i*sizelist:(i+1)*sizelist] , matrix_user_encoded.tocsr()[i*sizelist:(i+1)*sizelist] ]  )
    else : list_all.append( [list_index[i*sizelist:] , matrix_user_encoded.tocsr()[i*sizelist:] ])

这给了我一个包含 90 个 block 的列表:

[ [[1,1,2,3],[sparse1, sparse2, sparse3]] ,
  [[3,4,4,5],[sparse4, sparse5, sparse6]] ,
  ... ,
  ]

然后我过滤以便每个子列表具有不同的索引值:

i=0
size_list = len(list_all)
while i<size_list-1 :
    last_elem = list_all[i][0][len(list_all[i][0])-1]
    first_elem = list_all[i+1][0][0]
    first_sparse = list_all[i+1][1][0]
    while first_elem==last_elem :
        list_all[i][0].append(first_elem)
        list_all[i][1] = sp.vstack((list_all[i][1],first_sparse))
        list_all[i+1][0] = list_all[i+1][0][1:]
        list_all[i+1][1] = list_all[i+1][1][1:]
        if len(list_all[i+1][0])==0 :
            list_all.remove(list_all[i+1])
            size_list -= 1
            if i+1==size_list : break
        first_elem = list_all[i+1][0][0]
    i +=1

它有效，但由于我有很多输入(约 1800 万条条目)，它需要 6 个小时!

我需要我的程序在 2 小时内运行，因为它需要每天调用多次。是否存在根据第一个子列表的模式来剪切我的 2 个列表的 python 命令？

感谢您的帮助!

编辑:运行示例:

from scipy.sparse import csr_matrix

list_index = [0,0,1,2,2,3,4,5,5,6,6,7,7,7,8]
arr = np.random.random(size=(len(list_index), 5))
arr[arr < .7] = 0
matrix_user = csr_matrix(arr)
chunksize = 4

查看您可以使用的矩阵:

print(pd.SparseDataFrame(matrix_user))

Answer 1

经过多次改进，我找到了解决方案:而不是将 2 个输入列表切割成 90 个部分，然后按每个子列表具有不同索引值的顺序进行过滤，我为 list_index 提取所有可能的组合，然后切成 90 个 block 。

matrix_user = encoder.fit_transform(dfuser[['col1','col2']].values)

list_part_index = []
list_unique = list(dfuser.idx.unique())
for elem in list_unique : 
    list_part_index.append(dfuser[dfuser['idx']==elem].index[0])


nb_jump = int(len(list_unique)/90)
list_index = dfuser['idx'].tolist()
list_all = []
last_elem = list_part_index[0]
for elem in range(0, len(list_part_index),nb_jump) :
    if list_part_index[elem]>0  :
        list_all.append(  [list_index[last_elem:list_part_index[elem]] , matrix_user_encoded.tocsr()[last_elem:list_part_index[elem]] ]  )
    last_elem = elem
list_all.append(  [list_index[last_elem:] , matrix_user_encoded.tocsr()[last_elem:] ]  )   

我的程序现在可以在 22 分钟内运行!