今天在使用pytorch进行训练，在运行 loss.backward() 误差反向传播时出错 ：RuntimeError: grad can be implicitly created only for scalar outputs。那么在loss反向传播是出错要怎么办呢？今天小编就带来了相应的解决方案，希望能对小伙伴有所帮助。
 
 
 
File "train.py", line 143, in train
 loss.backward()
 File "/usr/local/lib/python3.6/dist-packages/torch/tensor.py", line 198, in backward
 torch.autograd.backward(self, gradient, retain_graph, create_graph)
 File "/usr/local/lib/python3.6/dist-packages/torch/autograd/__init__.py", line 94, in backward
 grad_tensors = _make_grads(tensors, grad_tensors)
 File "/usr/local/lib/python3.6/dist-packages/torch/autograd/__init__.py", line 35, in _make_grads
 raise RuntimeError("grad can be implicitly created only for scalar outputs")
 RuntimeError: grad can be implicitly created only for scalar outputs
 
 
问题分析：
 
因为我们在执行 loss.backward() 时没带参数，这与 loss.backward(torch.Tensor(1.0)) 是相同的，参数默认就是一个标量。
 
但是由于自己的loss不是一个标量，而是二维的张量，所以就会报错。
 
解决办法：
 
1. 给 loss.backward() 指定传递给后向的参数维度：
 
loss = criterion(pred, targets)
loss.backward()
# 改为：
loss = criterion(pred, targets)
loss.backward(loss.clone().detach())
 
2. 修改loss函数的输出维度
 
把张量的输出修改为标量，比如说多多个维度的loss求和或求均值等。此方法对于某些任务不一定适用，可以尝试自己修改。
 
criterion = nn.L1Loss(reduction='none')
# 把参数去掉，改为：
criterion = nn.L1Loss()
 
这里顺便介绍一下pytorch loss函数里面 的reduction 参数
 
在新的pytorch版本里，使用reduction 参数取代了旧版本的size_average和reduce参数。
 
reduction 参数有三种选择：
 
'elementwise_mean'：为默认情况，表明对N个样本的loss进行求平均之后返回(相当于reduce=True，size_average=True);
 
'sum'：指对n个样本的loss求和(相当于reduce=True，size_average=False);
 
'none'：表示直接返回n分样本的loss(相当于reduce=False)
 
补充：在Pytorch下，由于反向传播设置错误导致 loss不下降的原因及解决方案
 
在Pytorch下，由于反向传播设置错误导致 loss不下降的原因及解决方案
 
刚刚接触深度学习一段时间，一直在研究计算机视觉方面，现在也在尝试实现自己的idea，从中也遇见了一些问题，这次就专门写一下，自己由于在反向传播（backward）过程中参数没有设置好，而导致的loss不下降的原因。
 
对于多个网络交替
 
描述
 
简单描述一下我的网络结构，我的网络是有上下两路，先对第一路网络进行训练，使用groud truth对这一路的结果进行监督loss_steam1，得到训练好的feature.然后再将得到的feature级联到第二路，通过网络得到最后的结果，再用groud truth进行监督loss。
 
整个网络基于VGG19网络，在pytorch下搭建，有GPU环境：
 
 
出现的情况，loss_steam1不怎么下降
 
这个问题确实折麽自己一段时间，结果发现自己出现了一个问题，下面将对这个问题进行分析和解答：
 
PyTorch梯度传递
 
在PyTorch中，传入网络计算的数据类型必须是Variable类型， Variable包装了一个Tensor，并且保存着梯度和创建这个Variablefunction的引用，换句话说，就是记录网络每层的梯度和网络图，可以实现梯度的反向传递.
 则根据最后得到的loss可以逐步递归的求其每层的梯度，并实现权重更新。
 
在实现梯度反向传递时主要需要三步：
 
1、初始化梯度值：net.zero_grad() 清除网络状态
 
2、反向求解梯度：loss.backward() 反向传播求梯度
 
3、更新参数：optimizer.step() 更新参数
 
解决方案
 
自己在写代码的时候，还是没有对自己的代码搞明白。在反向求解梯度时，对第一路没有进行反向传播，这样肯定不能使这一路的更新，所以我就又加了一步：
 
loss_steam1.backward( retain_graph = True) //因为每次运行一次backward时，如果不加retain_graph = True，运行完后，计算图都会free掉。
 
loss.backward()
 
这样就够了么？我当时也是这么认为的结果发现loss_steam1还是没有降，又愁了好久，结果发现梯度有了，不更新参数，怎么可能有用！
 
optimizer_steam1.step() //这项必须加
optimizer.step()
 
哈哈！这样就完成了，效果也确实比以前好了很多。

此文章仅为本人的学习笔记，侵权删。
 
视频地址： 【尚学堂】AI人工智能PyTorch深度学习进阶教程_PyTorch反向传播推导_代码实现神经网络算法_PyTorch神经网络_PyTorch深度学习课程
 
 参考文章：
 
 
“反向传播算法”过程及公式推导（超直观好懂的Backpropagation）
 这讲了正向传播和反向传播的具体过程。
 
 
反向传播算法（过程及公式推导）
 这篇文章讲了反向传播算法的推导
 
 
 
代码练习：
 
数据集：数据
 
 
Python实现神经网络完成手写数字识别任务
 
激活函数是relu，输出层是softmax分类
 
 
import numpy as np
from sklearn.datasets import fetch_mldata
from sklearn.utils.extmath import safe_sparse_dot
 
# 由于输入层需要10个节点，所以最好把目标数字0-9做成One Hot编码的形式
def tran_y(y_true):
    y_ohe = np.zeros(10)
    y_ohe[int(y_true)] = 1
    return y_ohe
 
mnist = fetch_mldata('MNIST original', data_home='data/for_my_own_nn_data/')

X, y = mnist["data"], mnist["target"]
print(X.shape)
print(y.shape)
y = np.array([tran_y(y[i]) for i in range(len(y))])


hidden_layer_sizes = [300, 100] #隐藏层个数：一个300，一个100
max_iter = 200
alpha = 0.0001  # 正则项系数
learning_rate = 0.001
 
(70000, 784)
(70000,)
 
def log_loss(y_true, y_prob): #交叉熵
    """
    计算logistic loss对于分类任务
    """
    y_prob = np.clip(y_prob, 1e-10, 1 - 1e-10)
    if y_prob.shape[1] == 1:
        y_prob = np.append(1 - y_prob, y_prob, axis=1)
    if y_true.shape[1] == 1:
        y_true = np.append(1 - y_true, y_true, axis=1)
    return -np.sum(y_true * np.log(y_prob)) / y_prob.shape[0]
 
def softmax(x): #实现softmax非线性变换
    tmp = x - x.max(axis=1)[:, np.newaxis]
    np.exp(tmp, out=x)
    x /= x.sum(axis=1)[:, np.newaxis]
    return x

 
def relu(x):
    np.clip(x, 0, np.finfo(x.dtype).max, out=x) 
    return x

 
def relu_derivative(z, delta):
    """
    实现relu的导数
    """
    delta[z == 0] = 0#z==0执行，不等于0不执行
 
def gen_batches(n, bs):
    """
    产生一个批次的样本数据的索引
    :param n: 样本总数
    :param bs: batch_size批大小
    :return: 一个批次样本的索引
    """
    start = 0
    for _ in range(int(n // bs)):
        end = start + bs
        yield slice(start, end)
        start = end
    if start < n:
        yield slice(start, n)

 
n_samples, n_features = X.shape
n_outputs = y.shape[1]

batch_size = min(200, n_samples)
layer_units = ([n_features] + hidden_layer_sizes + [n_outputs]) 
#神经元个数：输入层神经元：[n_features] 隐藏：hidden_layer_sizes 输出层：[n_outputs]
n_layers = len(layer_units)#共有多少层
 
# 初始化W和b
coefs_ = []
intercepts_ = []
for i in range(n_layers - 1):#初始化各层的w与b
    fan_in = layer_units[i]
    fan_out = layer_units[i + 1]
    # 推荐的初始化方法Xavier Glorot.论文得出
    factor = 6.
    init_bound = np.sqrt(factor / (fan_in + fan_out))
    coef_init = np.random.uniform(-init_bound, init_bound, (fan_in, fan_out))
    intercept_init = np.random.uniform(-init_bound, init_bound, fan_out)
    coefs_.append(coef_init)
    intercepts_.append(intercept_init)
 
# 初始化一些集合用于存放正向传播层层结果，反向传播层层梯度结果和中间数据deltas
# activations存放每一层的输出，输入层就是X，其它层先构建好输出的形状
activations = [X]
activations.extend(np.empty((batch_size, n_fan_out)) for n_fan_out in layer_units[1:]) #每层设置一个空矩阵来存储结果
# 求梯度时候必要的一部分，grads = a*deltas
deltas = [np.empty_like(a_layer) for a_layer in activations]#每层设置一个空矩阵来存储结果
# 初始化层与层之间的W矩阵对应计算出来的gradients
coef_grads = [np.empty((n_fan_in_, n_fan_out_)) for n_fan_in_, n_fan_out_
              in zip(layer_units[:-1], layer_units[1:])]
# 初始化隐藏层到输出层对应的bias对应计算出来的gradients
intercept_grads = [np.empty(n_fan_out_) for n_fan_out_ in
                   layer_units[1:]]

loss_ = 0.0
 
# mini batch 梯度下降
for it in range(max_iter):#轮次
    arr = np.arange(n_samples)
    np.random.shuffle(arr)
    X = X[arr]
    y = y[arr]
    accumulated_loss = 0.0

    for batch_slice in gen_batches(n_samples, batch_size):#批次
        batch_X = X[batch_slice]
        batch_y = y[batch_slice]
        # 赋值输入层数据
        activations[0] = batch_X

        # 正向传播
        for i in range(n_layers - 1):
            activations[i + 1] = safe_sparse_dot(activations[i], coefs_[i])
            activations[i + 1] += intercepts_[i]
            # 对于隐藏层
            if (i + 1) != (n_layers - 1):
                activations[i + 1] = relu(activations[i + 1])
        # 对于最后一层输出层
        activations[i + 1] = softmax(activations[i + 1])

        # 计算平均Loss
        loss = log_loss(batch_y, activations[-1])
        # 给Loss添加L2正则项
        values = np.sum(np.array([np.dot(s.ravel(), s.ravel()) for s in coefs_]))
        loss += (0.5 * alpha) * values / len(batch_y)
        accumulated_loss += loss * len(batch_y)

        # 反向传播

        # last是指反向传播从后面第一个要开始计的算层的索引号
        last = n_layers - 2
        # 这里计算delta[last]适用于输出非线性变换和损失函数的组合：
        # softmax and categorical cross entropy
        # 为了去计算倒数第一个W矩阵的梯度，先计算last对应的deltas
        deltas[last] = activations[-1] - batch_y

        # 计算倒数第一个W矩阵的梯度，即从输出层返回过来的梯度
        # 1,base loss对应的梯度
        coef_grads[last] = safe_sparse_dot(activations[last].T, deltas[last])
        # 2,L2 loss对应的梯度
        coef_grads[last] += (alpha * coefs_[last])
        # 3,梯度求平均
        coef_grads[last] /= n_samples
        # 4,截距项,base loss对应的梯度
        intercept_grads[last] = np.mean(deltas[last], 0)

        # 迭代计算各个隐藏层前面的W矩阵对应的梯度
        for i in range(n_layers - 2, 0, -1):
            # deltas_previous = deltas * W * 激活函数的导
            deltas[i - 1] = safe_sparse_dot(deltas[i], coefs_[i].T)
            # 应用上激活函数relu的导
            relu_derivative(activations[i], deltas[i - 1])

            # 计算每个隐藏层前面的W矩阵的梯度
            # 1,base loss对应的梯度
            coef_grads[i - 1] = safe_sparse_dot(activations[i - 1].T, deltas[i - 1])
            # 2,L2 loss对应的梯度
            coef_grads[i - 1] += (alpha * coefs_[i - 1])
            # 3,梯度求平均
            coef_grads[i - 1] /= n_samples
            # 4,截距项,base loss对应的梯度
            intercept_grads[i - 1] = np.mean(deltas[i - 1], 0)

        # 梯度下降更新参数

        # 这里的+号不是numpy数组之间的计算，而是python原生的list列表拼接
        # grads: list, length = len(coefs_) + len(intercepts_)
        grads = coef_grads + intercept_grads
        updates = [-learning_rate * grad for grad in grads]
        # Wt+1 = Wt - learning_rate * grad
        # params: list, length = len(coefs_) + len(intercepts_)
        params = coefs_ + intercepts_
        for param, update in zip(params, updates):
            param += update

    loss_ = accumulated_loss / X.shape[0]
    print("Iteration %d, loss = %.8f" % (it, loss_))

    # TO DO ：
    # 连续10次loss变换幅度小于阈值, break跳出

    # TO DO ：
    # 一次迭代后调整一次学习率

    # TO DO ：
    # train_test_split评估一下测试集准确率


 
Iteration 0, loss = 16.41843381
Iteration 1, loss = 12.05028002
Iteration 2, loss = 9.59518521
Iteration 3, loss = 8.07381126
Iteration 4, loss = 7.05051051
Iteration 5, loss = 6.34085800
Iteration 6, loss = 5.80947574
Iteration 7, loss = 5.39779761
Iteration 8, loss = 5.06627548
Iteration 9, loss = 4.78721871
Iteration 10, loss = 4.55101589
Iteration 11, loss = 4.35204685
Iteration 12, loss = 4.17534207
Iteration 13, loss = 4.02260116
Iteration 14, loss = 3.88357171
Iteration 15, loss = 3.76303320
Iteration 16, loss = 3.65209822
Iteration 17, loss = 3.55253729
Iteration 18, loss = 3.46278989
Iteration 19, loss = 3.37840236
Iteration 20, loss = 3.30269155
Iteration 21, loss = 3.23202948
Iteration 22, loss = 3.16538411
Iteration 23, loss = 3.10627120
Iteration 24, loss = 3.04794362
Iteration 25, loss = 2.99438211
Iteration 26, loss = 2.94299062
Iteration 27, loss = 2.89611537
Iteration 28, loss = 2.85032957
Iteration 29, loss = 2.80667936
Iteration 30, loss = 2.76552825
Iteration 31, loss = 2.72595690
Iteration 32, loss = 2.68790869
Iteration 33, loss = 2.65275958
Iteration 34, loss = 2.61760695
Iteration 35, loss = 2.58602208
Iteration 36, loss = 2.55289127
Iteration 37, loss = 2.52326688
Iteration 38, loss = 2.49402990
 

  在学习《深度学习入门：基于 Python 的理论与实现》153页的代码时，我对SoftmaxWithLoss层的反向传播实现产生了疑问，
 
class SoftmaxWithLoss:
 def __init__(self):
 	self.loss = None # 损失
 	self.y = None # softmax的输出
 	self.t = None # 监督数据（one-hot vector）
 	
 def forward(self, x, t):
	 self.t = t
	 self.y = softmax(x)
	 self.loss = cross_entropy_error(self.y, self.t)
 	return self.loss
 	
 #反向传播代码实现
 def backward(self, dout=1):
 	batch_size = self.t.shape[0]
 	dx = (self.y - self.t) / batch_size # 为什么要除以批数量
 	return dx
 

 代码1
 

 
  回顾书上给的计算图，图1中，反向输出的结果是没有除以batch_size的。为什么该层的反向传递值要除以批数量呢？
 
 

 图1
 

 
分割线-------------------------------------------------------------------------------------------------- 



   思考后我突然意识到，图1中的计算图是batch_size=1的情况，而在代码1中，batch_size不等于1，在实现cross_entropy_error层时，一定对输出结果Loss进行了处理
（Loss/batch_size)，因此
图1是不完整的，导致反向输出结果是不完整的。 
交叉熵计算过程源码如下
 
def cross_entropy_error(y, t):
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)
        
    # 监督数据是one-hot-vector的情况下，转换为正确解标签的索引
    if t.size == y.size:
        t = t.argmax(axis=1)
             
    batch_size = y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size # 根据批数量求得平均值
 

 代码2
 

 
分割线-------------------------------------------------------------------------------------------------- 



   因此，完整的计算图见图2。
图2中反向输出结果符合代码1的backward函数。（注：新增计算图部分理论上属于交叉熵误差层，为方便补充单列出来） 


 图2

 
问题解决。

 
文章目录
 
两个反向传播
背景
代码实现
   
可学习参数
背景
代码实现
  
 

 
两个反向传播
 
背景
 
设计一个网络存在两个阶段，第一阶段的输出作为第二阶段的输入，并且在两个阶段的结束都分别有引入监督。此时不想简单将两个阶段的损失相加送入网络训练，而是将两个阶段的损失分别用来训练两个子网络。其实也可以理解为两个网络级联。
 
代码实现
 
import torch
import torch.nn as nn
from torch.optim import Adam

epoch = 100
learning_rate = 1e-3

# 子网络1
myNet_1 = nn.Conv2d(32, 32, 3, 1, 1)
optimizer_1 = Adam(myNet_1.parameters(), lr=learning_rate)
loss_fun_1 = nn.MSELoss()

# 子网络2
myNet_2 = nn.Conv2d(32, 32, 3, 1, 1)
optimizer_2 = Adam(myNet_2.parameters(), lr=learning_rate)
loss_fun_2 = nn.L1Loss()

x = torch.randn([10, 32, 64, 64])
y = torch.randn([10, 32, 64, 64])

# 开始训练
for i in range(epoch):
    output_1 = myNet_1(x)
    loss_1 = loss_fun_1(output_1, y)
    optimizer_1.zero_grad()
    loss_1.backward()  # 反向传播
    optimizer_1.step()

    output_2 = myNet_2(output_1.detach())  # 子网络1的输出与网路解耦
    loss_2 = loss_fun_1(output_2, y)
    optimizer_2.zero_grad()
    loss_2.backward()
    optimizer_2.step()
 
可学习参数
 
背景
 
网络存在多个输入，不同输入对于最终结果的贡献不同，如果设置可学习的参数来使网络自己学习合适的权重大小应该可以提升网络表现。
 
代码实现
 
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam

# 网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 设置可学习权值
        self.w1 = nn.Parameter(torch.FloatTensor(1), requires_grad=True)
        self.w2 = nn.Parameter(torch.FloatTensor(1), requires_grad=True)

        # 初始化权值
        self.w1.data.fill_(0.5)
        self.w2.data.fill_(0.5)

        # 两个卷积层
        self.conv1 = nn.Conv2d(32, 32, 3, 1, 1)
        self.conv2 = nn.Conv2d(32, 32, 3, 1, 1)

    def forward(self, x):

        x = self.w1 * self.conv1(x) + self.w2 * self.conv2(x)
        return F.relu(x)


epoch = 100
learning_rate = 1e-3

myNet = Net()
optimizer = Adam(myNet.parameters(), lr=learning_rate)
loss_fun = nn.MSELoss()

x = torch.randn([10, 32, 64, 64])
y = torch.randn([10, 32, 64, 64])

# 开始训练
for i in range(epoch):
    
    output = myNet(x)
    loss = loss_fun(output, y)
    optimizer.zero_grad()
    loss.backward()  # 反向传播
    optimizer.step()

    print(f'权值1：{myNet.w1.item()}')
    print(f'权值2：{myNet.w2.item()}')