没有 Numpy 的嵌套列表的递归迭代

Question

我想遍历一个嵌套列表。我只找到了 Numpy 的解决方案（在其他情况下为 ->），但我想知道如果没有 Numpy，这是否可能。

import numpy as np

def matrix_mulitplication(A, B):
    n = A.shape[0]

    if n == 1:
        return A * B
    else:
        i = int(n / 2)

        C = np.zeros((n, n), dtype=np.int)

        C[:i, :i] = matrix_mulitplication(A[:i, :i], B[:i, :i]) + matrix_mulitplication(A[:i, i:], B[i:, :i])

        C[:i, i:] = matrix_mulitplication(A[:i, :i], B[:i, i:]) + matrix_mulitplication(A[:i, i:], B[i:, i:])

        C[i:, :i] = matrix_mulitplication(A[i:, :i], B[:i, :i]) + matrix_mulitplication(A[i:, i:], B[i:, :i])

        C[i:, i:] = matrix_mulitplication(A[i:, :i], B[:i, i:]) + matrix_mulitplication(A[i:, i:], B[i:, i:])

        return C

x = np.array([[1, 2], [3, 4]])
y = np.array([[1, 2], [3, 4]])

print(matrix_mulitplication(x, y))

输出：

[[ 7 10]
 [15 22]]

我对第一个切片案例的想法：

c_one = [C[i][0:int(len(C) / 2)] for i in range(0,int(len(C) / 2))]

Answer 1

在numpy 中，您只是在进行二维矩阵乘法，可以用多种方式表示，例如np.dot、np.einsum 或（新的）@ 运算符

In [1]: x = np.array([[1, 2], [3, 4]])
In [2]: x@x
Out[2]: 
array([[ 7, 10],
       [15, 22]])

要对列表做同样的事情，让我们逐步完成任务

在代数中，我学会了用一根手指划过行，另一根手指划过列。所以让我们用列表理解来做：

In [6]: x1 = x.tolist()
In [7]: x2 = x.tolist()
In [8]: [[(row1,col2) for col2 in zip(*x2)] for row1 in x1]
Out[8]: [[([1, 2], (1, 3)), ([1, 2], (2, 4))], [([3, 4], (1, 3)), ([3, 4], (2, 4))]]

行和列的配对看起来是正确的。 zip(*xl) 是“转置”列表的习语（相当于 numpy 中的 x.T）

现在定义一个执行一维乘法的辅助函数：

In [9]: def mult(row,col):
   ...:     return [i*j for i,j in zip(row,col)]
   ...: 
   ...: 
In [10]: [[mult(row1,col2) for col2 in zip(*x2)] for row1 in x1]
Out[10]: [[[1, 6], [2, 8]], [[3, 12], [6, 16]]]

现在添加总和。我可以回去修改mult，但在外部理解中进行修改同样容易。

In [12]: [[sum(mult(row1,col2)) for col2 in zip(*x2)] for row1 in x1]
Out[12]: [[7, 10], [15, 22]]

或者结合所有的列表推导，形成一个不可读的行：

In [14]: [[sum(i*j for i,j in zip(row1,col2)) for col2 in zip(*x2)] for row1 in x1]
Out[14]: [[7, 10], [15, 22]]

---

对于这个 2x2 示例，我的结果与您的结果相同，但您采用了不同的方法，将原始数组拆分为块。可以与很好地切片的numpy 数组一起工作。但我不确定它对列表有帮助。我们必须尝试其他示例。

我的使用 3x3 数组

In [29]: y = np.arange(9).reshape(3,3)
In [30]: [[sum(mult(row1,col2)) for col2 in zip(*y.tolist())] for row1 in y.toli
    ...: st()]
Out[30]: [[15, 18, 21], [42, 54, 66], [69, 90, 111]]
In [31]: y@y
Out[31]: 
array([[ 15,  18,  21],
       [ 42,  54,  66],
       [ 69,  90, 111]])

你的失败，在 3x3 上出现形状广播错误，但在 4x4 上效果相同。

In [32]: y = np.arange(16).reshape(4,4)
In [33]: y@y
Out[33]: 
array([[ 56,  62,  68,  74],
       [152, 174, 196, 218],
       [248, 286, 324, 362],
       [344, 398, 452, 506]])
In [34]: [[sum(mult(row1,col2)) for col2 in zip(*y.tolist())] for row1 in y.toli
    ...: st()]
Out[34]: 
[[56, 62, 68, 74],
 [152, 174, 196, 218],
 [248, 286, 324, 362],
 [344, 398, 452, 506]]
In [35]: matrix_mulitplication(y,y)
Out[35]: 
array([[ 56,  62,  68,  74],
       [152, 174, 196, 218],
       [248, 286, 324, 362],
       [344, 398, 452, 506]])

因此，您的递归是将 4x4 分解为 2x2 块，然后分解为 1x1。我的将 2d 数组分解为 1d 乘积和。

Answer 2

尝试复制您的 nxn 块细分。我使用了blk 辅助函数来复制二维数组切片：

import numpy as np

def matrix_mulitplication(A, B):
    def blk(x,i1,i2):
        return [row[i2] for row in x[i1]]

    n = len(A) # A.shape[0]

    if n == 1:
        #print(A)
        return A[0][0] * B[0][0]
    else:
        i = int(n / 2)
        i1, i2 = slice(None,i), slice(i,None)
        #C = np.zeros((n, n), dtype=np.int)
        C1 = matrix_mulitplication(blk(A, i1, i1), blk(B,i1,i1)) +\
             matrix_mulitplication(blk(A, i1, i2), blk(B,i2,i1))

        C2 = matrix_mulitplication(blk(A, i1, i1), blk(B,i1,i2)) +\
             matrix_mulitplication(blk(A, i1, i2), blk(B,i2,i2))

        C3 = matrix_mulitplication(blk(A, i2, i1), blk(B,i1,i1)) +\
             matrix_mulitplication(blk(A, i2, i2), blk(B,i2,i1))

        C4 = matrix_mulitplication(blk(A, i2, i1), blk(B,i1,i2)) +\
             matrix_mulitplication(blk(A, i2, i2), blk(B,i2,i2))
        C = [[C1,C2],[C3,C4]]
        return C

x = np.array([[1, 2], [3, 4]])
y = np.arange(16).reshape(4,4)

z = matrix_mulitplication([[1]],[[2]])
print(z)
z = matrix_mulitplication(x.tolist(), x.tolist())
print(z)
print(x@x)
z = matrix_mulitplication(y.tolist(), y.tolist())
print(z)
print(y@y)

这适用于一级递归，但不适用于两级：

1253:~/mypy$ python3 stack50552791.py 
2
[[7, 10], [15, 22]]
[[ 7 10]
 [15 22]]
[[[[4, 5], [20, 29], [52, 57], [132, 145]], [[6, 7], [38, 47], [62, 67], [158, 171]]], [[[36, 53], [52, 77], [212, 233], [292, 321]], [[70, 87], [102, 127], [254, 275], [350, 379]]]]
[[ 56  62  68  74]
 [152 174 196 218]
 [248 286 324 362]
 [344 398 452 506]]

第2层的问题是matrix_mulitplication返回一个嵌套列表，而列表+被定义为concatenate，而不是元素添加。所以我必须定义另一个辅助函数（或 2 个）来正确解决这个问题。

好一点

def matrix_mulitplication(A, B):
    def blk(x,i1,i2):
        return [row[i2] for row in x[i1]]
    def add(x,y):
        if isinstance(x, list):
            return [add(i,j) for i,j in zip(x,y)]
        else:
            return x+y
    n = len(A) # A.shape[0]

    if n == 1:
        return A[0][0] * B[0][0]
    else:
        i = int(n / 2)
        i1, i2 = slice(None,i), slice(i,None)
        #C = np.zeros((n, n), dtype=np.int)
        C1 = add(matrix_mulitplication(blk(A, i1, i1), blk(B,i1,i1)) ,\
             matrix_mulitplication(blk(A, i1, i2), blk(B,i2,i1)))

        C2 = add(matrix_mulitplication(blk(A, i1, i1), blk(B,i1,i2)) ,\
             matrix_mulitplication(blk(A, i1, i2), blk(B,i2,i2)))

        C3 = add(matrix_mulitplication(blk(A, i2, i1), blk(B,i1,i1)) ,\
             matrix_mulitplication(blk(A, i2, i2), blk(B,i2,i1)))

        C4 = add(matrix_mulitplication(blk(A, i2, i1), blk(B,i1,i2)) ,\
             matrix_mulitplication(blk(A, i2, i2), blk(B,i2,i2)))
        C = [[C1,C2],[C3,C4]]
        return C

对于 4x4 的情况

[[[[56, 62], [152, 174]], [[68, 74], [196, 218]]], [[[248, 286], [344, 398]], [[324, 362], [452, 506]]]]
[[ 56  62  68  74]
 [152 174 196 218]
 [248 286 324 362]
 [344 398 452 506]]

数字都在那里，但在一个 4 深度的嵌套列表中。

因此，不仅将嵌套列表分解为二维块比使用数组更尴尬，重新组装它们也很尴尬。

https://en.wikipedia.org/wiki/Strassen_algorithm

在没有详细阅读 Strassen 算法的情况下，很明显，任何关于其效率的声明都假定A_ij 索引（对于单个元素或块）在获取值和设置 (C_ij) 时都是有效的。对于列表，A[i] 或 A[i:j] 相当有效，但 [row[i2] for row in x[i1] 则不然。

用[[a,b],[c,d]] 组装块是可以的，但是任何与[[C_11,C_12],[C_21,C_22]] 可比的东西，其中C 元素是块而不是标量，都是复杂的。

似乎 Strassen 的目标是减少所需的乘法次数。这假设（标量）乘法是矩阵乘法中最昂贵的部分。对于 Python 列表，情况显然并非如此。访问元素的成本更高。

麻木作弊

我可以将 4x4 机箱中的 z 改造成

arr = np.array(z)
arr = arr.transpose(0,2,1,3).reshape(4,4)

这在numpy 中要容易得多。