熵与全连接层

熵

熵是信息量的期望值，它是一个随机变量的确定性的度量。熵越大，变量的取值越不确定，反之就越确定。

import torch
a = torch.full([4],1/4.)
print(-(a*torch.log2(a)).sum())     #a,b,c假设四个选项选择正确的概率
#tensor(2.)                           #熵越小说明越没有意外，熵越大则不确定越大
b = torch.tensor([0.1,0.1,0.1,0.7])
print(-(b*torch.log2(b)).sum())
#tensor(1.3568)
c = torch.tensor([0.001,0.001,0.001,0.999])
print(-(c*torch.log2(c)).sum())
#tensor(0.0313)

---

 交叉熵

 相对熵又称为KL散度，KL距离，是两个随机分布间距离的度量。记为DKL(p||q)DKL(p||q)。它度量当真实分布为p时，假设分布q的无效性

---

 对于两个分布p（真实样本分布），q（待估计模型）都是（0-1）有

---

 对 H（p,q）= H(p) + Dkl(p|q ) , 当p已知时，可以把H(p)看做一个常数，此时交叉熵与KL距离在行为上是等价的，都反映了分布p，q的相似程度。最小化交叉熵等于最小化KL距离。它们都将在p=q时取得最小值H(p)（p=q时KL距离为0）

---

全连接层

nn.Linear(input，output，bias=TRUE)

        它相当于是包含w 的转置，和b（个人理解）

        用于设置网络中的全连接层，需要注意的是全连接层的输入与输出都是二维张量

        一般形状为[batch_size, size]，不同于卷积层要求输入输出是四维张量

        input：输入二维张量的大小

        output：输出二维张量的大小

如果不使用nn.Linear,创建的二维tensor的输入输出是相反的，即【output，input】要进行转置

import torch
import torch.nn as nn
x = torch.randn(1,784)
print(x.shape)      #torch.Size([1, 784])
layer1 = nn.Linear(784,200)     #第一个是in，第二个是out
layer2 = nn.Linear(200,200)
layer3 = nn.Linear(200,10)

x = layer1(x)
print(x.shape)      #torch.Size([1, 200])   ,降维
x = layer2(x)
print(x.shape)      #torch.Size([1, 200])   ，特征提取
x = layer3(x)
print(x.shape)      #torch.Size([1, 10])    ，降为10

---

nn.Relu vs F.relu

 nn.Relu使用的是类方法，F.relu使用的是函数方法，注意字母大小写

relu中的inplace默认为FALSE

inplace = False 时,不会修改输入对象的值,而是返回一个新创建的对象

inplace = True 时,会修改输入对象的值,所以打印出对象存储地址相同，节省反复申请与释放内存的空间与时间,只是将原来的地址传递,效率更好

import torch
import torch.nn as nn
from torch.nn import functional as F
x = torch.randn(1,10)

x = F.relu(x,inplace=True)
print(x)    #tensor([[0.0000, 0.0000, 0.0000, 0.0000, 0.9487, 1.0720, 0.0000, 0.0000, 0.3956, 0.0000]])
layer = nn.ReLU()
x = layer(x)
print(x)    #tensor([[0.0000, 0.0000, 0.0000, 0.0000, 0.9487, 1.0720, 0.0000, 0.0000, 0.3956, 0.0000]])

---

关于激活函数relu

sigmoid和tanh是“饱和激活函数”，而ReLU及其变体则是“非饱和激活函数”。使用“非饱和激活函数”的优势在于两点：
    1.“非饱和激活函数”能解决所谓的“梯度消失”问题。
    2.它能加快收敛速度。

---

leaky relu 

ReLU是将所有的负值都设为零，Leaky ReLU是给所有负值赋予一个非零斜率，默认0.01

用法和relu相同，可设置角度

---

 SELU函数

 是一个组合函数

---

 Softplus

将relu函数x轴接近0部分平滑化

---

使用GPU加速

device = torch.device('cuda:0')    # 使用设备，可以选择将需要运算的搬到你需要的设备。

#将要加速的送到GPU
o = nn.CrossEntropyLoss().to(device)    #使用.to()方法指定GPU加速，会返回个inference,他的类型取决于原来的类型
t = nn.CrossEntropyLoss().cuda()        #使用.cuda()方法

---

计算准确度

logits = torch.rand(4,10)
pred = F.softmax(logits,dim=1)

pred_label = pred.argmax(dim=1)
print(pred_label)       #tensor([5, 5, 2, 6])

p = logits.argmax(dim=1)
print(p)        #tensor([5, 5, 2, 6])

label = torch.tensor([3,9,2,0])
correct = torch.eq(pred_label,label) #
print(correct)  #tensor([False, False,  True, False])

i = correct.sum().float().item()/4  #计算准确度，item得到里面元素
print(i)    #0.25