小白学习之pytorch框架(4)-softmax回归(torch.gather()、torch.argmax()、torch.nn.CrossEntropyLoss())

学习pytorch路程之动手学深度学习-3.4-3.7

置信度、置信区间参考：https://cloud.tencent.com/developer/news/452418 本人感觉还是挺好理解的

交叉熵参考博客：https://www.cnblogs.com/kyrieng/p/8694705.html   https://blog.csdn.net/tsyccnh/article/details/79163834  个人感觉还不错，好理解

(这段瞅瞅就行了)torchvision包，服务于PyTorch深度学习框架的，用于构建计算机视觉模型，主要构成有：

　　torchvision.datasets:加载数据的函数及常用的数据集接口

　　torchvision.mdoels:包含常用的模型结构(含预训练模型)，例如AlexNet、VGG、ResNet等

　　torchvision.transforms:常用的图片变换，例如裁剪、旋转等

　　torchvision.utils:其他一些有用的方法

一行里画出多张图像和对应标签的函数

def show_fashion_mnist(images, labels):
    use_svg_display()
    # 这里的_表示我们忽略(不使用)的变量
    _, figs = plt.subplots(1, len(images), figsize=(12, 12))
　　
　　# subplots(row, cloumn, figsize=(12, 12)) row：子图的行数，即有几行；column：子图的列数，即一行有几个图；
　　# figsize：子图的Height和Width 其他参数请参考博客https://www.cnblogs.com/zhouzhe-blog/p/9614761.html 感谢大佬
　　# fig, ax = subplots() fig:返回一个图像fig(这是一个整幅图像，含有子图)；ax：返回子图列表(fig的子图)

    for f, img, lbl in zip(figs, images, labels):
　　　　 # zip()把可迭代的对象中的元素打包成一个个的元组，返回这些元组的列表。若是可迭代对象的元素个数不一致，
　　　　 # 则返回列表的长度与最短的对象相同https://www.runoob.com/python/python-func-zip.html　　 　　
        f.imshow(img.view((28, 28)).numpy()) # imshow(x,cmap) x表示要显示图片的变量，cmap为颜色图谱，默认为RGB(A)
        # imshow()其他参数可百度
　　　　 f.set_title(lbl) # 设置图像标题
        f.axes.get_xaxis().set_visible(False) # 设置x轴不可见
        f.axes.get_yaxis().set_visible(False)　# 设置y轴不可见
    plt.show()

查看数据集前10个图片及对应标签

X, y = [], []
for i in range(10):
    X.append(mnist_train[i][0])  # 每个图片对应的tensor(形状如torch.size([1, 28, 28]))附加到列表X中
    y.append(mnist_train[i][1])　 # 每个图像对应的labels的数字代表（即用0-9代替了标签）
show_fashion_mnist(X, get_fashion_mnist_labels(y)) 
# get_fashion_mnist_labels()通过数字获取对应的标签  show_fashion_mnist()显示图片和对应的label

softmax回归实现

　　torch.gather()函数的理解

　　下面说说我对gather()函数的理解，gather(input,dim,index,out=None)，对于gather函数我百度了一些解释，参考了一些博客，如  https://www.jianshu.com/p/5d1f8cd5fe31  (对dim=0时的三维tensor解释的可以)   https://blog.csdn.net/edogawachia/article/details/80515038

以上述第一个博客的tensor为例，

input = tensor([[[18.,   5.,   7.,   1.,   1.],
         　　　　 [  3.,  26.,   9.,   7.,   9.],
         　　　　 [ 10.,  28.,  22.,  27.,   0.]],

        　　　　 [[ 26.,  10.,  20.,  29.,  18.],
         　　　　 [  5.,  24.,  26.,  21.,   3.],
         　　　　 [ 10.,  29.,  10.,   0.,  22.]]])
index = torch.LongTensor([[[0,1,2,0,2],
                          [0,0,0,0,0],
                          [1,1,1,1,1]],
                        [[1,2,2,2,2],
                         [0,0,0,0,0],
                         [2,2,2,2,2]]])
首先明确tensor的形状是（2，3，5），即第一层中括号里有2个维度，第二层中括号里有3个维度，第三层中括号里有5个维度，所以（2，3，5）
dim = 1
　　即用index里值修改代替index对应位置的数值的下标中第2个下标值。例如index中下标为(0,0,0)的对应值0,用对应值0替换
　　下标中第2个值0得出(0,0,0),然后去input中取下标为(0,0,0)的值18放入输出tensor下标(0,0,0)对应位置；index中下标为(0,0,1)的对应
　 值1，用对应值1替换下标中第2个值得出(0,1,1),取出input中下标为(0,1,1)的值为26放入输出tensor下标(0,0,1)对应位置；index中下标为(1,0,1)
　　对应值2，用对应值2替换下标中第2个值得出(1,2,1),取出input中下标为(1,2,1)的值为29放入输出tensor下标(1,0,1)对应位置。
　　依次类推，得出输出tensor如下：
　　tensor([[[ 18., 26., 22., 1., 0.],
　　　　　　　　[ 18., 5., 7., 1., 1.],
　　　　　　　　[ 3., 26., 9., 7., 9.]],
　　　　　　　　[[ 5., 29., 10., 0., 22.],
　　　　　　　　[ 26., 10., 20., 29., 18.],
　　　　　　　　[ 10., 29., 10., 0., 22.]]])
dim = 2
　　同理dim=1，这次只不过是替换下标中第3个值。如index中下标为(0,0,4)的对应值2，替换后得(0,0,2),取input值为7
index2 = torch.LongTensor([[[0,1,1,0,1],
                          [0,1,1,1,1],
                          [1,1,1,1,1]],
                        [[1,0,0,0,0],
                         [0,0,0,0,0],
                         [1,1,0,0,0]]])
dim = 0
　　同理dim=1，这次是替换下标中第1个值。如index2中下标为(0,0,1)的对应值1，替换后的(1,0,1),取input值为10

torch.argmax()函数的理解

　　我真是菜的一批，看了好久(一看就困)，以博客 https://blog.csdn.net/weixin_42494287/article/details/92797061 的三维的例子为例，说一下个人的理解

a=torch.tensor([
              [
                  [1, 5, 5, 2],
                  [9, -6, 2, 8],
                  [-3, 7, -9, 1]
              ],
              [
                  [-1, 7, -5, 2],
                  [9, 6, 2, 8],
                  [3, 7, 9, 1]
              ]])
# a的形状为(2,3,4)比较时，若是第一块和第二块比，值一样，则取第二块的位置值;dim表示维度，要干掉的维度
b=torch.argmax(a,dim=0)
　　dim=0，干掉第一维，也就是剩下(3,4),即红色中括号里对应位置数字相比，第一个红色中括号对应位置数字大，则取0，否则取1。
　　值相同取第二个红色中括号对应值1(对应上面的黑色粗体字)。(为什么取0/1？)
　　结果：
　　tensor([[0, 1, 0, 1],
　　　　　　[1, 1, 1, 1],
　　　　　　[1, 1, 1, 1]])
c=torch.argmax(a,dim=1)
　　dim=1，干掉第二维，也就是剩下(2,4),即蓝色和荧光绿色中括号里对应位置数字相对，蓝色剩一行，荧光绿色剩一行。以蓝色为例，第一个蓝色中括号
　　数值大则取0，第二个蓝色中括号数值大则取1，第三个蓝色中括号数值大则取2。(为什么取0/1/2？)
　　结果：
　　tensor([[1, 2, 0, 1],
　　　　　　[1, 2, 2, 1]])
d=torch.argmax(a,dim=2)
　　dim=2，干掉第三维，也就是剩下(2,3),即红色中括号为2，蓝色和荧光绿色为3，也就是蓝色和荧光绿色中括号里剩一个值并转置(或者说取了值后放
　　在一个列表里)。例如：第一个蓝色中括号：有2个5，取第二个5，取值2；第二个蓝色中括号：9最大，取值0；第三个蓝色中括号：7最大，取值1。组成列表为[2,0,1]
　　结果：
　　tensor([[2, 0, 1],
　　　　　　[1, 0, 2]])
二维也一样，去掉某一维即可

看明白了argmax函数后，torch.sum(input,dim,output)也就懂了，不过sum是把要干掉的维度上数求和(即合并成一个)

torch.nn.CrossEntropyLoss()

　　这个交叉熵损失函数把input tensor进行了softmax()、log()、NLLLoss()计算，即三合一。见博客 https://blog.csdn.net/qq_22210253/article/details/85229988 博主写的很好，感谢博主