np.argmax()

1.对一个一维向量

import numpy as np
a = np.array([3, 1, 2, 4, 6, 1])
b=np.argmax(a)#取出a中元素最大值所对应的索引，此时最大值位6，其对应的位置索引值为4，（索引值默认从0开始）
print(b)#4

2.对2维向量（通常意义下的矩阵）a[][]

import numpy as np
a = np.array([[1, 5, 5, 2],
              [9, 6, 2, 8],
              [3, 7, 9, 1]])
b=np.argmax(a, axis=0)#对二维矩阵来讲a[0][1]会有两个索引方向，第一个方向为a[0]，默认按列方向搜索最大值
#a的第一列为1，9，3,最大值为9，所在位置为1，
#a的第一列为5，6，7,最大值为7，所在位置为2，
#此此类推，因为a有4列，所以得到的b为1行4列，
print(b)#[1 2 2 1]

c=np.argmax(a, axis=1)#现在按照a[0][1]中的a[1]方向，即行方向搜索最大值，
#a的第一行为1，5，5，2,最大值为5（虽然有2个5，但取第一个5所在的位置），索引值为1，
#a的第2行为9，6，2，8,最大值为9，索引值为0，
#因为a有3行，所以得到的c有3个值，即为1行3列
print(c)#[1 0 2]

3.对于三维矩阵a[0][1][2],情况最为复制，但在lstm中应用最广

import numpy as np
a = np.array([
              [
                  [1, 5, 5, 2],
                  [9, -6, 2, 8],
                  [-3, 7, -9, 1]
              ],

              [
                  [-1, 7, -5, 2],
                  [9, 6, 2, 8],
                  [3, 7, 9, 1]
              ],
            [
                  [21, 6, -5, 2],
                  [9, 36, 2, 8],
                  [3, 7, 79, 1]
              ]
            ])
b=np.argmax(a, axis=0)#对于三维度矩阵，a有三个方向a[0][1][2]
#当axis=0时，是在a[0]方向上找最大值，即两个矩阵做比较，具体
#(1)比较3个矩阵的第一行，即拿[1, 5, 5, 2],
#                         [-1, 7, -5, 2],
#                         [21, 6, -5, 2],
#再比较每一列的最大值在那个矩阵中，可以看出第一列1，-2，21最大值为21，在第三个矩阵中，索引值为2
#第2列5，7，6最大值为7，在第2个矩阵中，索引值为1.....，最终得出比较结果[2 1 0 0]
#再拿出三个矩阵的第二行，按照上述方法，得出比较结果 [0 2 0 0]
#一共有三个，所以最终得到的结果b就为3行4列矩阵
print(b)
#[[0 0 0 0]
 #[0 1 0 0]
 #[1 0 1 0]]

c=np.argmax(a, axis=1)#对于三维度矩阵，a有三个方向a[0][1][2]
#当axis=1时，是在a[1]方向上找最大值，即在列方向比较，此时就是指在每个矩阵内部的列方向上进行比较
#(1)看第一个矩阵
                  # [1, 5, 5, 2],
                  # [9, -6, 2, 8],
                  # [-3, 7, -9, 1]
#比较每一列的最大值，可以看出第一列1，9，-3最大值为9，，索引值为1
#第2列5，-6，7最大值为7，，索引值为2
# 因此对第一个矩阵，找出索引结果为[1，2，0,1]
#再拿出2个，按照上述方法，得出比较结果 [1 0 2 1]
#一共有三个，所以最终得到的结果b就为3行4列矩阵
print(c)
#[[1 2 0 1]
 # [1 0 2 1]
 # [0 1 2 1]]

d=np.argmax(a, axis=2)#对于三维度矩阵，a有三个方向a[0][1][2]
#当axis=2时，是在a[2]方向上找最大值，即在行方向比较，此时就是指在每个矩阵内部的行方向上进行比较
#(1)看第一个矩阵
                  # [1, 5, 5, 2],
                  # [9, -6, 2, 8],
                  # [-3, 7, -9, 1]
#寻找第一行的最大值，可以看出第一行[1, 5, 5, 2]最大值为5，，索引值为1
#第2行[9, -6, 2, 8],最大值为9，，索引值为0
# 因此对第一个矩阵，找出行最大索引结果为[1，0，1]
#再拿出2个矩阵，按照上述方法，得出比较结果 [1 0 2 1]
#一共有三个，所以最终得到的结果d就为3行3列矩阵
print(d)
# [[1 0 1]
#  [1 0 2]
#  [0 1 2]]
###################################################################
#最后一种情况，指定矩阵a[0, -1, :]，第一个数字0代表取出第一个矩阵（从前面可以看出a有3个矩阵）为
# [1, 5, 5, 2],
# [9, -6, 2, 8],
# [-3, 7, -9, 1]
#第二个数字“-1”代表拿出倒数第一行，为
# [-3, 7, -9, 1]
#这一行的最大索引值为1

# ，-1，代表最后一行
m=np.argmax(a[0, -1, :])
print(m)#1

#h,取a的第2个矩阵
# [-1, 7, -5, 2],
# [9, 6, 2, 8],
# [3, 7, 9, 1]
#的第3行
# [3, 7, 9, 1]
#的最大值为9，索引为2
h=np.argmax(a[1, 2, :])
print(h)#2

g=np.argmax(a[1,:, 2])#g,取出矩阵a，第2个矩阵的第3列为-5，2，9,最大值为9，索引为2
print(g)#2