已知：
 二阶导数在灰度斜坡和灰度台阶过渡处会产生双边缘响应。
 二阶导数的符号可以用于确定边缘的过渡是从亮到暗还是暗到亮。
 
 斜坡开始处，二阶导数为负，斜坡结束二阶导数为正，斜坡上，二阶导数为0.（亮到暗边缘）
 零交叉点的定义：零灰度轴和二阶导数极值的连线的交点称为该二阶导数的零交叉点
 
 一条边缘的两个附加性质：
 （1）对图像中的每条边缘，二阶导数生成两个值
   (2)二阶导数的零交叉点可用于定位粗边缘的中心
   总结:二阶导数提取边缘往往产生双边缘。而 通过求零交叉点可以确定边缘的中心，从而避免了产生双边缘的不方便。

转： 图像二阶导数的推导
 
前面我们介绍过了图像的梯度，以及图像的几个梯度算子。
 
这些本质上都是一阶导数，或一阶微分。就是求图像灰度变化的导数，能够突出图像中的对象边缘。那有一阶导数，有没有二阶导数呢？求导数的导数，这对灰度变化强烈的地方会更敏感。
 
在微积分中，一维函数的一阶微分的基本定义是这样的：
 
dfdx=limϵ→0f(x+ϵ)−f(x)ϵ
 dfdx=limϵ→0f(x+ϵ)−f(x)ϵ
 那么，二阶微分的基本定义就是这样的： 
 d2fdx2=limϵ→0f′(x+ϵ)−f′(x)ϵ
 d2fdx2=limϵ→0f′(x+ϵ)−f′(x)ϵ
 而图像是一个二维函数f(x,y)，其二阶微分当然就是二阶偏微分。但为推导简单起见，我们先按x方向的一维函数来推导：
 
∂f∂x=limϵ→0f(x+ϵ)−f(x)ϵ
 ∂f∂x=limϵ→0f(x+ϵ)−f(x)ϵ
 图像是按照像素来离散的，最小的ϵϵ就是1像素。因此有： 
 ∂f∂x=f′(x)=f(x+1)−f(x)
 ∂f∂x=f′(x)=f(x+1)−f(x)
 
那么二阶微分就是：
 ∂2f∂x2=∂f′(x)dx2=f′(x+1)−f′(x)
 ∂2f∂x2=∂f′(x)dx2=f′(x+1)−f′(x)
 根据上面的一阶微分，则： 
 ∂2f∂x2=∂f′(x)dx2=f′(x+1)−f′(x)
 ∂2f∂x2=∂f′(x)dx2=f′(x+1)−f′(x)
 =f((x+1)+1)−f((x+1))−(f(x+1)−f(x))
 =f((x+1)+1)−f((x+1))−(f(x+1)−f(x))
 
=f(x+2)−f(x+1)−f(x+1)+f(x)
 =f(x+2)−f(x+1)−f(x+1)+f(x)
 
=f(x+2)−2f(x+1)+f(x)
 =f(x+2)−2f(x+1)+f(x)
 令x=x-1 
 则： 
 ∂2f∂x2=f(x+1)+f(x−1)−2f(x)
 ∂2f∂x2=f(x+1)+f(x−1)−2f(x)
 于是，在x和y方向上，有： 
 ∂2f∂x2=f(x+1,y)+f(x−1,y)−2f(x,y)
 ∂2f∂x2=f(x+1,y)+f(x−1,y)−2f(x,y)
 
∂2f∂y2=f(x,y+1)+f(x,y−1)−2f(x,y)
 ∂2f∂y2=f(x,y+1)+f(x,y−1)−2f(x,y)
 我们把x方向和y方向的二阶导数结合在一起：
 
∂2f∂x2+∂2f∂y2=f(x+1,y)+f(x−1,y)+f(x,y+1)+f(x,y−1)−4f(x,y)
 ∂2f∂x2+∂2f∂y2=f(x+1,y)+f(x−1,y)+f(x,y+1)+f(x,y−1)−4f(x,y)
 这实质上就是著名的拉普拉斯二阶微分算子（Laplacian）。我们看一下实际效果。
  
 
import cv2
import numpy as np

moon = cv2.imread("moon.tif", 0)
row, column = moon.shape
moon_f = np.copy(moon)
moon_f = moon_f.astype("float")

two = np.zeros((row, column))

for x in range(1, row - 1):
    for y in range(1, column - 1):
        two[x, y] = moon_f[x + 1, y] \
                    + moon_f[x - 1, y] \
                    + moon_f[x, y + 1] \
                    + moon_f[x, y - 1] \
                    - 4 * moon_f[x, y]

sharp = moon_f - two
sharp = np.where(sharp < 0, 0, np.where(sharp > 255, 255, sharp))
sharp = sharp.astype("uint8")

cv2.imshow("moon", moon)
cv2.imshow("sharp", sharp)
cv2.waitKey()
 
输出结果： 
 
 
我们可以看到，图像增强的效果比前几篇文章介绍的一阶微分要好很多。
 
需要注意，将原图像与拉普拉斯二阶导数图像合并的时候，必须考虑符号上的差别。注意上面的代码中用的是减号，而不是一阶导数中用的加号。到底用加号还是减号，与中心点f(x,y)的系数有关，这个定义的拉普拉斯二阶导数中，f(x,y)的系数是-4，是负的，原图像就要减去拉普拉斯二阶导数图像；拉普拉斯二阶导数还有其它的形式，例如： 
 Laplacian=4f(x,y)−f(x+1,y)−f(x−1,y)−f(x,y+1)−f(x,y−1)
 Laplacian=4f(x,y)−f(x+1,y)−f(x−1,y)−f(x,y+1)−f(x,y−1)
 这时f(x,y)的系数是正的，原图像就要加上拉普拉斯二阶导数图像。
 
到这里，我们已经注意到，前面介绍图像一阶导数时，用的是绝对值，而二阶导数就没有使用绝对值，且需要考虑系数的正负符号问题，才能决定最后的图像合并是用原图像加上还是减去二阶导数图像，为什么是这样？这个下一篇再探讨。
  

 
MAML代码及理论的深度学习 PyTorch二阶导数计算 【记录】
 
PyTorch二阶导数
torch.autograd.grad 函数
torch.nn.Conv2和nn.functional.conv2重要区别
MAML原理的深度理解
 

 
PyTorch二阶导数
 
torch.autograd.grad 函数
 
x=torch.tensor([2.0],requires_grad=True)
y=x**2

#首先是求一阶导数，显然为2x=4

grad=torch.autograd.grad(y,x,create_graph=True,retain_graph=True) #保存计算图
#y对x求导，x为参数，设置create_graph=True,retain_graph=True保存计算图

print(grad[0]) # 4

f=x-grad[0]  #此处参数为f=x-2*x=-x

print(f)   # -2

y=f*20    #y=20*(-x)

grad2=torch.autograd.grad(y,f) 
#此时y对f求导数，显然为20

grad3=torch.autograd.grad(y,x)
#此时y对x求导数，由于保存了一阶导数的计算图，所以此处为g=-1*20=-20
#如果没有保存一阶导数的计算图，所以此处为g=1*20=20
 
torch.nn.Conv2和nn.functional.conv2重要区别
 
在MAML的代码里发现用的是自己定义的权重w和偏置b，然后使用了 F.conv2d(x, w, b, stride=1, padding=0)这种写法，我还奇怪为什么不能用nn.Conv2d，如果是复杂的代码这不是更简单的吗？
 
然后发现nn.Conv2d这个卷积类它不！能！改！参！数！即使手动改了，后面梯度下降的时候它也会自己把自己改回去，所以就只能一个一个参数的写了？？？好大的工程量呀，偷懒失败！
 
MAML原理的深度理解
 
一直都不能理解MAML的原理，看了知乎大神们的分析，终于有一点了解了。MAML算法，model-agnostic metalearnings
 
MAML学习的就是初始化参数的规则。这个初始化的参数θ在参数空间中具有对每个任务最优参数解θ1,2,…n的高度敏感(其实就是梯度方向垂直)，使其能够在一步Gradient Descent中沿着梯度方向快速达到最优点。
 

 θ’是θ在support set上梯度下降的一步之后的结果，我们用这个θ‘在query set上计算损失，但是是对θ求导，而不是对θ’求导，就等与在这个过程中引入了θ的二阶导数信息。
 

 可以看到整个过程梯度的下降有后面的一个二阶导数的小尾巴。
 
但是呢，MAML对这个二阶导的计算做了近似，因为不近似的话二阶导要保存计算图，存储空降和计算速度都会受到影响，很是复杂。
 
 
 这个近似就是把二阶导数置为0了（？？？）这么粗暴的吗？这样在第二步梯度下降中，看似好像是L(θ‘)对θ在求导，但其实呢，L(θ‘)还是在对θ‘在求导
 
 所以这个时候的MAML代码就是没有保存计算图的版本。
 
for i in range(task_num):

    # 1. run the i-th task and compute loss for k=0
    logits = self.net(x_spt[i], vars=None, bn_training=True)
    loss = F.cross_entropy(logits, y_spt[i])
    #可以看到下面的这个grad的计算图没有保存
 	grad = torch.autograd.grad(loss, self.net.parameters())
 	fast_weights = list(map(lambda p: p[1] - self.update_lr * p[0], zip(grad, self.net.parameters())))
 	for k in range(1, self.update_step): #第二步更新了
 		logits = self.net(x_spt[i], fast_weights, bn_training=True)
 		loss = F.cross_entropy(logits, y_spt[i])
 		grad = torch.autograd.grad(loss, fast_weights) 
 		#这里就不用对net的参数求导，近似为对fastw求导
 		fast_weights = list(map(lambda p: p[1] - self.update_lr * p[0], zip(grad, fast_weights)))
 		logits_q = self.net(x_qry[i], fast_weights, bn_training=True)
        # loss_q will be overwritten and just keep the loss_q on last update step.
        loss_q = F.cross_entropy(logits_q, y_qry[i])
        losses_q[k + 1] += loss_q
    self.meta_optim.zero_grad()
    loss_q.backward()
    self.meta_optim.step()
    #这里的loss是对net的参数求导，虽然里面有fastw，但由于没有保存计算图，所以其对net的导数为1
 
如果需要引入二阶导（实验证明这样会有很大的提升），可以把第一步的计算图保存。
 
grad = torch.autograd.grad(loss, self.net.parameters(),create_graph=True,retain_graph=True)
 
但是只需要保存第一步梯度下降就可以啦。我还傻乎乎的把第二次的梯度下降的fastw改为net的参数又保存了一次计算图，这样就是求了三阶导数？
 
 实践证明这样的效果应该是最好的。
 
总而言之，最终的效果大概就是这样。
 
 
这个问题的本质就是不断在参数空间中寻找一个位置（这个位置不对应任何任务的最优解）最终收敛，但是这个位置却神奇地对应着很多任务最优解的最近处。用这个位置给模型进行初始化以后，具备朝任何一个给定的task最优参数的位置快速前进(只优化一步)的能力（来自知乎）。
 
这个图我很喜欢
 
 方案1 更可能分布在一个peak上，被每个task最优解围绕，容易收敛到最优解。 方案2 更像右图，试图找到一个单一解对所有task的泛化性能最好。
 
那么问题来了，该怎么把MAML应用到目标检测上去呢？

速度本身的变化率称为加速度，简单来说，就是导数的导数，记作f''(t)或者称作f(t)的二阶导数
 
伽利略（Galileo）观察到，经过时间t，自由落体经过的铅直距离x由公式：
 
x=f（x）=1/2gt²给出（1）
 
其中g为重力加速度，是一个常数，令g=9.8。
 
将式子微分，可得落体在时间t的速度公式：
 
v=f’（t）=gt（2）
 
而且加速度等于：
 
a = f’’（t）=g（3）
 
它是常数。
 
假设需求落体在下落后3秒时的速度。
 
在从t=3到t=3.1的时间间隔内的平均速度是：
 
（1/2g（3.1）²-1/2g(3)²）/（3.1-3.0）=   29.890000000000114（结果用matlab给出，format long格式）
 
然后t=3到t=3.01的时间间隔内的平均速度是：
 
（1/2g（3.01）²-1/2g(3)²）/（3.01-3.0）=   29.448999999999614（结果用matlab给出，format long格式）
 
然后t=3到t=3.01的时间间隔内的平均速度是：
 
（1/2g（3.001）²-1/2g(3)²）/（3.001-3.0）=   29.404899999995848（结果用matlab给出，format long格式）
 
最后令t=3，代入（2）式子，得v=f’（3）= 29.400000000000002（结果用matlab给出，format long格式）