🎯要点

🎯光学神经网络非相干光图像处理 | 🎯光电光对光处理多层光学神经网络 | 🎯光图像传感器构建两层神经网络 | 🎯非相干光输入图像映射到低维空间 | 🎯多层非线性对比浅层线性光神经网络 | 🎯模拟算法图像分类评估：手绘图形、生物细胞图像、实景三维对象。

📜光学和散射用例

🍪语言内容分比

🍇Python矩阵矢量乘法优化

数学定义

矩阵乘矩阵

如果$A$是$m\times n$矩阵并且$B$是$n\times p$矩阵
$$A=\left(\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}& a_{m2}& \cdots & a_{mn}\end{array}\right),B=\left(\begin{array}{cccc}{b}_{11}& b_{12}& \cdots & b_{1p}\\ b_{21}& b_{22}& \cdots & b_{2p}\\ ⋮& ⋮& \ddots & ⋮\\ b_{n1}& b_{n2}& \cdots & b_{np}\end{array}\right)$$
矩阵乘积 $C=AB$ （不带乘号或点表示）被定义为 $m\times p$ 矩阵
$$C=\left(\begin{array}{cccc}{c}_{11}& c_{12}& \cdots & c_{1p}\\ c_{21}& c_{22}& \cdots & c_{2p}\\ ⋮& ⋮& \ddots & ⋮\\ c_{m1}& c_{m2}& \cdots & c_{mp}\end{array}\right)$$
于是
$$c_{ij}=a_{i1}{b}_{1j}+a_{i2}{b}_{2j}+\cdots +a_{in}{b}_{nj}=\sum _{k=1}^n{a}_{ik}{b}_{kj}$$
对于 $i=1,\dots ,m$ 和 $j=1,\dots ,p$。

也就是说，乘积的条目$c_{ij}$是通过将$A$的第$i$行和$B$的第$j$列的条目逐项相乘，然后求和得到的这些 $n$ 乘积。换句话说，$c_{ij}$ 是$A$ 的第$i$ 行和$B$ 的第$j$ 列的点积。

因此，$AB$ 也可以写成
$$C=\left(\begin{array}{cccc}{a}_{11}{b}_{11}+\cdots +a_{1n}{b}_{n1}& a_{11}{b}_{12}+\cdots +a_{1n}{b}_{n2}& \cdots & a_{11}{b}_{1p}+\cdots +a_{1n}{b}_{np}\\ a_{21}{b}_{11}+\cdots +a_{2n}{b}_{n1}& a_{21}{b}_{12}+\cdots +a_{2n}{b}_{n2}& \cdots & a_{21}{b}_{1p}+\cdots +a_{2n}{b}_{np}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}{b}_{11}+\cdots +a_{mn}{b}_{n1}& a_{m1}{b}_{12}+\cdots +a_{mn}{b}_{n2}& \cdots & a_{m1}{b}_{1p}+\cdots +a_{mn}{b}_{np}\end{array}\right)$$
因此，当且仅当 $A$ 中的列数等于 $B$ 中的行数（在本例中为 $n$）时，才定义乘积 $AB$。

矩阵乘矢量

长度为 $n$ 的向量 $x$ 可以被视为列向量，对应于 $n\times 1$ 矩阵 $X$，其条目由 $X_{i1}=x_i$ 给出 如果 $A $ 是一个 $m\times n$ 矩阵，$Ax$ 表示的矩阵乘以向量乘积就是向量 $y$，将其视为列向量，等于 $m\times 1$ 矩阵$AX$。在索引表示法中，这相当于：
$$y_i=\sum _{j=1}^n{a}_{ij}{x}_j$$
看待这个问题的一种方法是假设从“普通”向量到列向量以及返回的变化是隐式的。

类似地，长度为 $n$ 的向量 $x$ 可以被视为行向量，对应于 $1\times n$ 矩阵。为了清楚地表明行向量的含义，在这种情况下通常将其表示为列向量的转置；因此，人们会看到诸如 $x^{T}A$ 之类的符号。

恒等式 $x^{T}A={\left(A^{T}x\right)}^T$ 成立。在索引表示法中，如果 $A$ 是 $n\times p$ 矩阵，则 $x^{T}A=y^T$ 相当于： $y_k={\sum }_{j=1}^n{x}_j{a}_{jk}$。

代码优化示例

许多数值计算库都具有高效的矢量化操作实现。矩阵乘法、查找点积等操作非常高效。这些操作的实现是为了利用 CPU 中的多个核心，并将计算卸载到 GPU（如果可用）。通常，矩阵和向量的操作由 BLAS（基本线性代数子程序）提供。一些示例是 Intel MKL、OpenBLAS、cuBLAS 等。

首先我们创建两个矩阵，以便我们可以用它来检查我们的实现是否正确。

import tensorflow as tf
import numpy as np
tf.__version__ # 2.0.0

a = np.random.normal(size=(200, 784)).astype('float32')
b = np.random.normal(size=(784, 10)).astype('float32')

expected = np.matmul(a, b)

不使用外部库实现功能，

def py_matmul1(a, b):
    ra, ca = a.shape
    rb, cb = b.shape
    assert ca == rb, f"{ca} != {rb}"
    
    output = np.zeros(shape=(ra, cb))
    for i in range(ra):
        for j in range(cb):
            for k in range(rb):
                output[i, j] += a[i, k] * b[k, j]
                
    return output

%time result = py_matmul1(a, b)
assert result.shape == expected.shape
assert np.allclose(result, expected, rtol=1e-02), (result, expected)

执行时，在我的计算机上需要 1.38 秒。它相当慢，可以大大改进。如果您注意到，最内层循环基本上是在计算两个向量的点积。在这种情况下，两个向量分别是 a 和 b 的第 i 行和第 j 列。所以让我们用点积实现删除最内层循环。

矢量优化一：

def py_matmul2(a, b):
    ra, ca = a.shape
    rb, cb = b.shape
    assert ca == rb, f"{ca} != {rb}"
    
    output = np.zeros(shape=(ra, cb))
    for i in range(ra):
        for j in range(cb):
	        # we replaced the loop with dot product
            output[i, j] = np.dot(a[i], b[:,j])
                
    return output

%time result = py_matmul2(a, b)
assert result.shape == expected.shape
assert np.allclose(result, expected, rtol=1e-02), (result, expected)

此实现仅需 6 毫秒。与原始实现相比，这是一个巨大的改进。由于内部循环本质上是在计算点积，我们将其替换为 np.dot 函数，并传递矩阵 a 中的第 i 行和矩阵 b 中的第 j 列。

矢量优化二：

现在让我们删除迭代矩阵 b 的列的 for 循环。

def py_matmul3(a, b):
    ra, ca = a.shape
    rb, cb = b.shape
    assert ca == rb, f"{ca} != {rb}"
    
    output = np.zeros(shape=(ra, cb))
    for i in range(ra):
        output[i] = np.dot(a[i], b)
        
                
    return output

%time result = py_matmul3(a, b)
assert result.shape == expected.shape
assert np.allclose(result, expected, rtol=1e-02), (result, expected)

此实现耗时 2.97 毫秒。使用称为广播的技术，我们可以从本质上消除循环，仅使用一行 output[i] = np.dot(a[i], b)，我们就可以计算输出矩阵第 i 行的整个值。numpy 所做的是广播向量 a[i]，使其与矩阵 b 的形状相匹配。然后它计算每对向量的点积。广播规则在 numpy、tensorflow、pytorch 等主要库中几乎相同。

库优化三：

现在让我们使用 numpy 的内置 matmul 函数。

def py_matmul4(a, b):
    ra, ca = a.shape
    rb, cb = b.shape
    assert ca == rb, f"{ca} != {rb}"
    
    return np.matmul(a, b)
    

%time result = py_matmul4(a, b)
assert result.shape == expected.shape
assert np.allclose(result, expected, rtol=1e-02), (result, expected)

使用numpy的内置matmul函数，需要999 μ 𝜇 s。这是迄今为止我们实施的最快的。

库优化四：

在张量流中，它也与 numpy 非常相似。我们只需要调用 matmul 函数即可。

def py_matmul5(a, b):
    ra, ca = a.shape
    rb, cb = b.shape
    assert ca == rb, f"{ca} != {rb}"
    
    return tf.matmul(a, b)
    
tf_a = tf.constant(a)
tf_b = tf.constant(b)
%time result = py_matmul5(tf_a, tf_b)
assert result.shape == expected.shape
assert np.allclose(result, expected, rtol=1e-02), (result, expected)

TensorFlow 计算结果大约需要 999 μ s。我们可以直接传递 numpy 数组，而不必转换为 TensorFlow 张量，但执行速度会慢一些。在我的实验中，如果我只调用 py_matmul5(a, b)，大约需要 10 毫秒，但使用 tf.constant 函数将 numpy 数组转换为 tf.Tensor 可以获得更好的性能。

👉参阅、更新：计算思维 | 亚图跨际