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

🎯要点

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

📜用例 Python非线性光学映射数据压缩算法

🍪语言内容分比


🍇Python随机梯度下降算法

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

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

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

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

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

在分类问题中,输出 y y y 是分类的,通常为 0 或 1 。例如,您可能尝试预测电子邮件是否是垃圾邮件。在二进制输出的情况下,可以方便地最小化交叉熵函数,该函数也取决于实际输出 y i y_{ i } yi 和相应的预测 p ( x i ) p\left( x _{ i }\right) p(xi) :
H = − ∑ i ( y i log ⁡ ( p ( x i ) ) + ( 1 − y i ) log ⁡ ( 1 − p ( x i ) ) ) 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) H=−i∑(yilog(p(xi))+(1−yi)log(1−p(xi)))

在常用于解决分类问题的逻辑回归中,函数 p ( x ) p( x ) p(x) 和 f ( x ) f( x ) f(x) 定义如下:
p ( x ) = 1 1 + exp ⁡ ( − f ( x ) ) f ( x ) = b 0 + b 1 x 1 + ⋯ + b r x r \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} p(x)=1+exp(−f(x))1f(x)=b0+b1x1+⋯+brxr

同样,您需要找到权重 b 0 、 b 1 、 ... 、 b r b_0、b_1、\ldots、b_r b0、b1、...、br,但这一次它们应该最小化交叉熵函数。

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

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

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

基本梯度下降

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

Python 复制代码
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()之前,您可以添加另一个终止条件:

Python 复制代码
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

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

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

随机梯度下降算法

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

Python 复制代码
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()

随机梯度下降的动量

Python 复制代码
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()

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

相关推荐
jiang_huixin12 天前
PyTorch nn.Conv2d 空洞卷积
pytorch·深度学习·卷积神经网络
xiandong2018 天前
241011-在jupyter中实现文件夹压缩后下载
linux·前端·人工智能·学习·jupyter·卷积神经网络
Scalzdp24 天前
YOLO使用和深入学习01-卷积神经网络
人工智能·神经网络·学习·yolo·cnn·卷积神经网络
涩即是Null1 个月前
PyTorch实现卷积神经网络CNN
人工智能·pytorch·深度学习·神经网络·卷积神经网络
方世恩1 个月前
【深度学习】(8)--神经网络使用最优模型
人工智能·pytorch·深度学习·神经网络·卷积神经网络
阿_旭1 个月前
PyTorch构建卷积神经网络(CNN)训练模型:分步指南
人工智能·pytorch·深度学习·cnn·卷积神经网络
方世恩1 个月前
【深度学习】(6)--图像数据增强
人工智能·pytorch·深度学习·神经网络·卷积神经网络
方世恩1 个月前
【深度学习】(3)--损失函数
人工智能·python·深度学习·神经网络·算法·卷积神经网络
达柳斯·绍达华·宁2 个月前
感知算法引入时序模型的优势
深度学习·算法·卷积神经网络
菜就多练_08282 个月前
《深度学习》卷积神经网络CNN 原理及其流程解析
人工智能·深度学习·cnn·卷积神经网络