🍠Python(TensorFlow)衍射光学层卷积算法模拟(英伟达GPU)

Python(TensorFlow)衍射光学层卷积算法模拟(英伟达GPU) | 亚图跨际亚图跨际 on Notion

🏈指点迷津 | Brief

🎯要点

🎯衍射光学卷积算法模拟 | 🎯模拟或数字电子计算之前加入一层光学计算 | 🎯前馈卷积神经网络计算成像系统对输入图像进行分类 | 🎯相位掩模利用线性空间不变成像系统执行固有卷积

光学散射用例 | 亚图跨际亚图跨际 on Notion

🍪语言内容分比

✂️梗概

🍇Python随机梯度下降算法

成本函数或损失函数是通过改变决策变量来最小化（或最大化）的函数。许多机器学习方法都在解决表面下的优化问题。它们倾向于通过调整模型参数（如神经网络的权重和偏差、随机森林或梯度提升的决策规则等）来最小化实际输出和预测输出之间的差异。

在回归问题中，通常具有输入变量 $x =\left(x_1, \ldots, x_r\right)$ 的向量和实际输出 $y$。您想要找到一个将 $x$ 映射到预测响应 $f( x )$ 的模型，以便 $f( x )$ 尽可能接近 $y$。例如，您可能想要根据某人在公司工作的年数或教育水平等输入来预测某人的工资等输出。

您的目标是最小化预测 $f( x )$ 与实际数据 $y$ 之间的差异。这种差异称为残差。在此类问题中，您希望最小化残差平方和，其残差平方和 $=\Sigma_{ i }\left(y_{ i }-f\left( x _{ i }\right)\right )^2$ 对于所有观测值 $i=1, \ldots, n$，其中 $n$ 是观测值总数。或者，您可以使用均方误差 (MSE $=\operatorname{SSR} / n)$ 代替残差平方和。

最小化残差平方和和均方误差都使用实际输出和预测输出之差的平方。差异越小，预测越准确。差异为零表示预测与实际数据相同。

通过调整模型参数来最小化残差平方和或均方误差。例如，在线性回归中，你想要找到函数 $f( x )=b_0+b_1 x_1+\cdots+b_{ r } x_{ r }$，因此你需要确定权重 $b_0, b_1, \ldots , b_{ r }$ 最小化残差平方和或均方误差。

在分类问题中，输出 $y$ 是分类的，通常为 0 或 1 。例如，您可能尝试预测电子邮件是否是垃圾邮件。在二进制输出的情况下，可以方便地最小化交叉熵函数，该函数也取决于实际输出 $y_{ i }$ 和相应的预测 $p\left( x _{ i }\right)$ ：

$$H=-\sum_i\left(y_i \log \left(p\left( x _i\right)\right)+\left(1-y_i\right) \log \left(1-p\left( x _i\right)\right)\right)$$

在常用于解决分类问题的逻辑回归中，函数 $p( x )$ 和 $f( x )$ 定义如下：

$$\begin{gathered} p( x )=\frac{1}{1+\exp (-f( x ))} \\ f( x )=b_0+b_1 x_1+\cdots+b_r x_r \end{gathered}$$

同样，您需要找到权重 $b_0、b_1、\ldots、b_r$，但这一次它们应该最小化交叉熵函数。

在微积分中，函数的导数显示当您修改其参数时值的变化量。导数对于优化很重要，因为零导数可能表示最小值、最大值或鞍点。

多个自变量 $v_1, \ldots, v_{ r }$ 的函数 $C$ 的梯度用 $\nabla C\left(v_1, \ldots, v_{ r }\right)$ 表示，并定义为$C$对每个自变量的偏导数的向量函数：$\nabla C=\left(\partial C / \partial v_1, \ldots, \partial C / v_r\right)$。符号 $\nabla$ 称为 nabla。

函数 $C$ 在给定点的梯度的非零值定义了 $C$ 最快增长的方向和速率。使用梯度下降时，您对成本函数下降最快的方向感兴趣。该方向由负梯度 $-\nabla C$ 确定。

基本梯度下降

这是该算法的基本实现，从任意点开始，迭代地将其移向最小值，并返回一个有望达到或接近最小值的点：

def gradient_descent(gradient, start, learn_rate, n_iter):
    vector = start
    for _ in range(n_iter):
        diff = -learn_rate * gradient(vector)
        vector += diff
    return vector

在应用gradient_descent()之前，您可以添加另一个终止条件：

import numpy as np

def gradient_descent(
    gradient, start, learn_rate, n_iter=50, tolerance=1e-06
):
    vector = start
    for _ in range(n_iter):
        diff = -learn_rate * gradient(vector)
        if np.all(np.abs(diff) <= tolerance):
            break
        vector += diff
    return vector

您只需要一条语句来测试梯度下降实现：

>>> gradient_descent(
...     gradient=lambda v: 2 * v, start=10.0, learn_rate=0.2
... )
2.210739197207331e-06

随机梯度下降算法

随机梯度下降算法是梯度下降的一种改进。在随机梯度下降中，您仅使用观测值的随机一小部分而不是全部来计算梯度。在某些情况下，这种方法可以减少计算时间。

import numpy as np

def sgd(
    gradient, x, y, start, learn_rate=0.1, batch_size=1, n_iter=50,
    tolerance=1e-06, dtype="float64", random_state=None
):
    if not callable(gradient):
        raise TypeError("'gradient' must be callable")

    dtype_ = np.dtype(dtype)

    x, y = np.array(x, dtype=dtype_), np.array(y, dtype=dtype_)
    n_obs = x.shape[0]
    if n_obs != y.shape[0]:
        raise ValueError("'x' and 'y' lengths do not match")
    xy = np.c_[x.reshape(n_obs, -1), y.reshape(n_obs, 1)]

    seed = None if random_state is None else int(random_state)
    rng = np.random.default_rng(seed=seed)

    vector = np.array(start, dtype=dtype_)

    learn_rate = np.array(learn_rate, dtype=dtype_)
    if np.any(learn_rate <= 0):
        raise ValueError("'learn_rate' must be greater than zero")

    batch_size = int(batch_size)
    if not 0 < batch_size <= n_obs:
        raise ValueError(
            "'batch_size' must be greater than zero and less than "
            "or equal to the number of observations"
        )

    n_iter = int(n_iter)
    if n_iter <= 0:
        raise ValueError("'n_iter' must be greater than zero")

    tolerance = np.array(tolerance, dtype=dtype_)
    if np.any(tolerance <= 0):
        raise ValueError("'tolerance' must be greater than zero")

    for _ in range(n_iter):
        rng.shuffle(xy)

        for start in range(0, n_obs, batch_size):
            stop = start + batch_size
            x_batch, y_batch = xy[start:stop, :-1], xy[start:stop, -1:]
            grad = np.array(gradient(x_batch, y_batch, vector), dtype_)
            diff = -learn_rate * grad
            if np.all(np.abs(diff) <= tolerance):
                break
            vector += diff

    return vector if vector.shape else vector.item()

随机梯度下降的动量

import numpy as np

def sgd(
    gradient, x, y, start, learn_rate=0.1, decay_rate=0.0, batch_size=1,
    n_iter=50, tolerance=1e-06, dtype="float64", random_state=None
):
    if not callable(gradient):
        raise TypeError("'gradient' must be callable")

    dtype_ = np.dtype(dtype)
    x, y = np.array(x, dtype=dtype_), np.array(y, dtype=dtype_)
    n_obs = x.shape[0]
    if n_obs != y.shape[0]:
        raise ValueError("'x' and 'y' lengths do not match")
    xy = np.c_[x.reshape(n_obs, -1), y.reshape(n_obs, 1)]

    seed = None if random_state is None else int(random_state)
    rng = np.random.default_rng(seed=seed)

    vector = np.array(start, dtype=dtype_)
    learn_rate = np.array(learn_rate, dtype=dtype_)
    if np.any(learn_rate <= 0):
        raise ValueError("'learn_rate' must be greater than zero")
    decay_rate = np.array(decay_rate, dtype=dtype_)
    if np.any(decay_rate < 0) or np.any(decay_rate > 1):
        raise ValueError("'decay_rate' must be between zero and one")

    batch_size = int(batch_size)
    if not 0 < batch_size <= n_obs:
        raise ValueError(
            "'batch_size' must be greater than zero and less than "
            "or equal to the number of observations"
        )

    n_iter = int(n_iter)
    if n_iter <= 0:
        raise ValueError("'n_iter' must be greater than zero")

    tolerance = np.array(tolerance, dtype=dtype_)
    if np.any(tolerance <= 0):
        raise ValueError("'tolerance' must be greater than zero")

    diff = 0

    for _ in range(n_iter):
        # Shuffle x and y
        rng.shuffle(xy)

        for start in range(0, n_obs, batch_size):
            stop = start + batch_size
            x_batch, y_batch = xy[start:stop, :-1], xy[start:stop, -1:]

            grad = np.array(gradient(x_batch, y_batch, vector), dtype_)
            diff = decay_rate * diff - learn_rate * grad
            if np.all(np.abs(diff) <= tolerance):
                break
            vector += diff

    return vector if vector.shape else vector.item()