标签: backpropagation

为什么我们在计算权重时不能只使用阶跃函数，

weightChange = n * (t-o) * i

Where, n: learning rate;
t: target out;
o: actual out;
i: input

这适用于单层网络。我听说需要 sigmoid 来处理非线性问题，但为什么呢？

我一直在观看有关深度学习/卷积神经网络的一些视频,比如这里和这里,我试图在C++中实现我自己的.为了第一次尝试,我试图保持输入数据相当简单,所以想法是区分十字和圆,我有一个大约25个(64*64个图像)的小数据集,它们看起来像这样:

网络本身是五层:

Convolution (5 filters, size 3, stride 1, with a ReLU)
MaxPool (size 2) 
Convolution (1 filter, size 3, stride 1, with a ReLU)
MaxPool (size 2)
Linear Regression classifier

我的问题是我的网络没有任何融合.没有任何权重似乎发生变化.如果我运行它,预测大多数保持不变,而不是偶尔的异常值,它会在下一次迭代返回之前跳起来.

卷积层训练看起来像这样,删除了一些循环使其更清洁

// Yeah, I know I should change the shared_ptr<float>
void ConvolutionalNetwork::Train(std::shared_ptr<float> input,std::shared_ptr<float> outputGradients, float label)
{
    float biasGradient = 0.0f;

    // Calculate the deltas with respect to the input.
    for (int layer = 0; layer < m_Filters.size(); ++layer)
    {
        // Pseudo-code, each loop …

我尝试运行一个没有任何激活功能的简单神经网络,并且网络不会收敛.我正在使用MSE成本函数进行MNIST分类.

但是,如果我将整流线性激活函数应用于隐藏层(输出= max(0,x),其中x是加权和),则它会收敛.

为什么要消除前一层的负面输出有助于学习？

我一直在关注关于深度学习的在线教程。它有一个关于梯度下降和成本计算的实际问题，一旦将其转换为 python 代码，我就一直在努力获得给定的答案。希望你能帮助我得到正确的答案

请参阅以下链接以了解所使用的方程式 单击此处查看用于计算的方程式

以下是计算梯度下降、成本等的函数。需要在不使用 for 循环但使用矩阵操作操作的情况下找到这些值

import numpy as np

def propagate(w, b, X, Y):
"""
Arguments:
w -- weights, a numpy array of size (num_px * num_px * 3, 1)
b -- bias, a scalar
X -- data of size (num_px * num_px * 3, number of examples)
Y -- true "label" vector (containing 0 if non-cat, 1 if cat) of size
  (1, number of examples)

Return:
cost -- negative log-likelihood cost for logistic regression
dw -- …

如何在 epoch 上绘制 MSE，我想在训练数据集中可视化收敛率

from sklearn.neural_network import MLPRegressor 
from sklearn.metrics import mean_absolute_error

dataset = open_dataset("forex.csv")
dataset_vector = [float(i[-1]) for i in dataset]
normalized_dataset_vector = normalize_vector(dataset_vector)
training_vector, validation_vector, testing_vector = split_dataset(training_size, validation_size, testing_size, normalized_dataset_vector)
training_features = get_features(training_vector)
training_fact = get_fact(training_vector)
validation_features = get_features(validation_vector)
validation_fact = get_fact(validation_vector)

model = MLPRegressor(activation=activation, alpha=alpha, hidden_layer_sizes=(neural_net_structure[1],), max_iter=number_of_iteration, random_state=seed)
model.fit(training_features, training_fact)

pred = model.predict(training_features)
err = mean_absolute_error(pred, validation_fact)

print(err)

正如标题所示，我正在尝试基于 SimCLR 框架训练模型（见本文：https ://arxiv.org/pdf/2002.05709.pdf - NT_Xent 损失在等式（1）和算法 1 中说明） ）。

我设法创建了损失函数的 numpy 版本，但这不适合训练模型，因为 numpy 数组无法存储反向传播所需的信息。我很难将我的 numpy 代码转换为 Tensorflow。这是我的 numpy 版本：

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Define the contrastive loss function, NT_Xent
def NT_Xent(zi, zj, tau=1):
    """ Calculates the contrastive loss of the input data using NT_Xent. The
    equation can be found in the paper: https://arxiv.org/pdf/2002.05709.pdf
    
    Args:
        zi: One half of the input data, shape = (batch_size, feature_1, feature_2, ..., feature_N)
        zj: Other half of the …

我正在研究多层感知器，一种神经网络。当我读到反向传播算法时，我看到一些作者建议在计算特定层的所有错误后立即更新权重，但另一位作者解释说我们需要在获得所有层的所有错误后更新权重。正确的做法有哪些？

第一种方法：

function void BackPropagate(){
    ComputeErrorsForOutputLayer();
    UpdateWeightsOutputLayer();
    ComputeErrorsForHiddenLayer();
    UpdateWeightsHiddenLayer();
}

第二种方法：

function void BackPropagate(){
    ComputeErrorsForOutputLayer();
    ComputeErrorsForHiddenLayer();
    UpdateWeightsOutputLayer();
    UpdateWeightsHiddenLayer();
}

感谢一切。

我在一篇有关反向传播的文章中找到了这段代码，但我对它到底是如何工作的感到困惑。文章说如下

“这是我们这个神经网络的权重矩阵。它被称为“syn0”，意味着“突触零”。由于我们只有 2 层（输入和输出），所以我们只需要一个权重矩阵来连接它们。它的维度是（ 3,1) 因为我们有 3 个输入和 1 个输出。”

我想指定作者通过输入引用数组“X”，输出引用数组“Y”。

我的第一个问题是为什么文章声称我们只有 3 个输入。浏览一下代码就会发现我们的数组 X 的大小为 4。我是否误解了什么？

我的第二个问题是为什么将对 np.random.random() 的调用乘以 2？

谢谢您的帮助！

import numpy as np    

X = np.array([ [0,0,1],
               [0,1,1],
               [1,0,1],
               [1,1,1] ])

y = np.array([[0,0,1,1]]).T  

# initialize weights randomly with mean 0
syn0 = 2*np.random.random((3,1)) - 1

我正在 PyTorch 中使用线性回归示例。我知道我在 'with torch.no_grad():' 中包含 'loss.backward()' 是错误的，但是为什么它与我的代码运行良好？

根据pytorch docs，torch.autograd.no_grad是一个禁用梯度计算的上下文管理器。所以我真的很困惑。

代码在这里：

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
# Toy dataset
x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], 
                    [9.779], [6.182], [7.59], [2.167], [7.042], 
                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], 
                    [3.366], [2.596], [2.53], [1.221], [2.827], 
                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)

input_size = 1
output_size = 1
epochs = 100
learning_rate = 0.05 …