图文深度解析深度学习入门代码f = lambda w: net.loss(x, t)

 参考另一位博主发表的文章  解析深度学习入门代码f = lambda w: net.loss(x, t)

看完他的文章后收获了不少，但仍觉得不够直观形象，遂决定用图文的方式进行讲解

首先是关于lamda函数，可以参考这一篇博客  python中lambda的用法

个人觉得这部分的难点主要在于函数执行的流程，期间变量的变化情况

所以这边文章主要讲解函数执行流程，以及主要变量的变化情况。其实正真有精力的同学可以直接debug一下程序，看看程序一步步的执行过程，仔细观察执行过程中各变量发生的变化，也能够理解。

一.源代码

import numpy as np


def numerical_gradient(f, x):
    h = 1e-4 # 0.0001
    grad = np.zeros_like(x)
    
    it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
    while not it.finished:
        idx = it.multi_index
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x) # f(x+h)
        
        x[idx] = tmp_val - h 
        fxh2 = f(x) # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2*h)
        
        x[idx] = tmp_val # 还原值
        it.iternext()   
        
    return grad

def softmax(x):
    if x.ndim == 2:
        x = x.T
        x = x - np.max(x, axis=0)
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T 

    x = x - np.max(x) # 溢出对策
    return np.exp(x) / np.sum(np.exp(x))


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

class simpleNet:
    def __init__(self):
        self.W = np.random.randn(2,3)
        print(self.W)

    def predict(self, x):
        return np.dot(x, self.W)

    def loss(self, x, t):
        z = self.predict(x)
        y = softmax(z)
        loss = cross_entropy_error(y, t)

        return loss

x = np.array([0.6, 0.9])
t = np.array([0, 0, 1])

net = simpleNet()

f = lambda w: net.loss(x, t)
dW = numerical_gradient(f, net.W)

print(dW)

二、代码执行流程解析

 如上图，注意区别全局环境和函数内部的局部环境(特别是注意全局变量里面的x和函数内部的x，要加以区别， 全局变量x是全过程都恒定不变的)

由于net.W是会被随机初始化一个2×3的矩阵，所以为了演示方便这里随便写了一个矩阵

当执行下列语句时

dw = numerical_gradient(f, net.W)

进入到函数numerical_gradient()内部，函数的形参f等于f函数， 函数形参x等于net.W，当执行到

x[idx] = float(tmp_val) + h

这句话等价于net.W[idx] = float(tmp_val) + h

如上图所示，特别要注意的是 由于net.W是以引用的方式传入函数内部的，所以当net.W在函数内部发生变化的时候，外面的全局变量net.W的值也会发生改变

接着执行fxh1 = f(x)

如上图所示，这句话等价于 fxh1 = f(net.W)， 执行这条语句之后，处理机的执行环境就会切换到外面的全局环境当中

接下来是关键部分

第一点、f(net.W)会去执行net.loss(x, t),   由于前面一直和大家强调执行环境的问题，所以这里大家应该能够明白，net.loss(x, t)里面的x是全局变量x，而不是numerical_gradient()里面的x。

第二点、 当执行net.loss(x, t)的时候，会间接执行net.predict(x)，也就是会间接使用到net.W，而此时net.W已经有一个元素发生了改变，因此最后的结果也会发生改变

第三点、 每次在函数numerical_gradient() 改变x[idx]并使用它完成计算之后，都会把x[idx]再恢复初始值，这样就保证了每次只改变x(即net.W)中的某一个元素而其它元素不变，以满足求梯度。

第四点、 我们再仔细观察一下f函数，它的原型其实是长这个样子

def f(W):
    return net.loss(x, t)

书中强调W是一个假参数, 因为W不论传入什么，都不影响最后的结果，诶，那么既然W不参与运算的话，那么我传入任意参数是不是都不影响结果呢。我们可以试一试

把函数numerical_gradient() 里面的fxh1 = f(x) 我改成 fxh1 = f(0), 这里的0是我瞎写的，当然你也可以改成任意数，都不影响最后的结果，感兴趣的同学可以试一试（试的时候记得把net.W设置为固定数值的矩阵，不然每次运行都会产生一个随机的矩阵不方便看演示效果）

以上就是函数执行流程中的关键部分了，其余部分比较好理解就不讲解了，接下来再讲一下为什么要设置这个假参数，删掉可以吗？

三、可不可以把f函数改成无参函数呢

上面我们聊到了函数f 中的形参W不参与运算，那么我们为何不直接把f函数设置为一个无参构造函数呢，答案是可以的，但是从大局观来看是不可取的，下面就来解释一下

我们把f函数改成无参构造函数之后

def f():
    return net.loss(x, t)

我们还需要修改一下函数numerical_gradient()里面的下面这部分代码

fxh1 = f()  # f(x+h)
x[idx] = tmp_val - h
fxh2 = f()  # f(x-h)

这样才可以满足要求，这样看来代码似乎清爽了许多，也更容易理解了，从这个场景下来看确实是没问题的。

但是像numerical_gradient()这种常用函数一般是固定不变的，在项目中，它常常存在于某个文件夹下，每次使用的时候再导入、调用它，而很少会去改写这个函数。

每遇到一个新的使用场景就去修改一下numerical_gradient()的代码确实是不可取的，而

fxh1 = f(x)  # f(x+h)
x[idx] = tmp_val - h
fxh2 = f(x)  # f(x-h)

带参的f(x)更符合我们的理解和大多数使用场景，因此我们就需要将带参的f(x)设计成统一标准,  所以在这个场景中，虽然我们用不上形参，但是为了大局观，为了满足统一标准，还是要设置一个假参数