深入理解numpy中argmax的具体使用

目录
  • 一、基本介绍
  • 二、代码实验
    • 1、一维数组情况
      • 1.1、axis=0
      • 1.2、axis=1
    • 2、二维数组情况
      • 2.1、axis=0
      • 2.2、axis=1
    • 3、三维数组情况
      • 3.1、axis=0
      • 3.2、axis=1
      • 3.3、axis=2
      • 3.4、axis=-1
  • 四、Reference
  • PS:补充

一、基本介绍

numpy中的argmax简而言之就是返回最大值的索引,当使用np.argmax(axis),这里方向axis的指定往往让人不理解。
简而言之:这里axis可以让我们从、或者是深度方向来看一个高维数组。

二、代码实验

1、一维数组情况

简单一维情况,np.argmax()直接返回最大值的索引,不指定axis可以认为是将数组拉平之后寻找最大值的索引

1.1、axis=0

当我们指定axis=0时,其实是在中作比较,寻找最大的的索引

当然对于这个一维情况没有什么影响。

1.2、axis=1

当我们指定axis=1的时候报错了,这是因为我们的a是一维数组,没有axis=1这个轴,可见当我们使用np.argmax()时axis的指定不能超过所需要排序的数组

2、二维数组情况

不指定axis就是相当于把二维数组拉平,直接选取最大值的索引

2.1、axis=0

指定axis=0就是比较,返回索引中的最大值

我们改写一个b中的元素,我们期望的结果是[2,2,1,2]

实际结果和我们期望相符合

2.2、axis=1

指定axis=0就是比较,返回索引中的最大值

3、三维数组情况

一个三维数组可以视作一张图片,它的三个维度分别为(high, width, channels) 分别表示图像的高、宽、通道数(深度)。常见的彩色图像都有三个通道,我们以常见的RGB图像为例构建一个数组。

直接使用np.argmax(),就是之间将三维数组拉平,寻找最大值的索引

3.1、axis=0

单独查看c的三个通道的数据,如图所示

对于三个通道取axis=0意味分别比较列返回行的最大值索引

我们期望的返回值应该是[[1,1,1,],[1,1,1],[1,1,1]],实际的结果和我们的期望一致

3.2、axis=1

对于三个通道取axis=1意味分别比较行返回列的最大值索引

我们期望的结果是[[2, 2, 2],[2, 2, 2],[2, 2, 2],[2, 2, 2]],,实际的结果和我们的期望一致

3.3、axis=2

取axis=2意味着我们从图像的深度方向(通道方向)来进行比较,可以认为三个数组的叠在一起的,分别对应channel0,channel1,channel2而我们取最大值的索引就是返回对应pixel像素所在的通道索引

c的channel2所有的像素值均大于其他两个channel所有返回值应该是[[2,2,2,],[2,2,2,],[2,2,2,],[2,2,2,]],实际结果和我的期望一致

3.4、axis=-1

axis=-1即是反过来看轴,对于三维情况axis=-1axis=2一致

其他
对于二维情况axis=-1anxis=1一致
对于一维情况axis=0anxis=-1一致

四、Reference

https://blog.csdn.net/weixin_39190382/article/details/105854567

https://www.cnblogs.com/zhouyang209117/p/6512302.html

PS:补充

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

到此这篇关于深入理解numpy中argmax的具体使用的文章就介绍到这了,更多相关numpy argmax内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 详解numpy的argmax的具体使用

    从最简单的例子出发 假定现在有一个数组a = [3, 1, 2, 4, 6, 1]现在要算数组a中最大数的索引是多少.这个问题对于刚学编程的同学就能解决.最直接的思路,先假定第0个数最大,然后拿这个和后面的数比,找到大的就更新索引.代码如下 a = [3, 1, 2, 4, 6, 1] maxindex = 0 i = 0 for tmp in a: if tmp > a[maxindex]: maxindex = i i += 1 print(maxindex) 这个问题虽然简单.但是可以帮助

  • 深入理解numpy中argmax的具体使用

    目录 一.基本介绍 二.代码实验 1.一维数组情况 1.1.axis=0 1.2.axis=1 2.二维数组情况 2.1.axis=0 2.2.axis=1 3.三维数组情况 3.1.axis=0 3.2.axis=1 3.3.axis=2 3.4.axis=-1 四.Reference PS:补充 一.基本介绍 numpy中的argmax简而言之就是返回最大值的索引,当使用np.argmax(axis),这里方向axis的指定往往让人不理解.简而言之:这里axis可以让我们从行.列.或者是深度

  • 详解Numpy中的数组拼接、合并操作(concatenate, append, stack, hstack, vstack, r_, c_等)

    Numpy中提供了concatenate,append, stack类(包括hsatck.vstack.dstack.row_stack.column_stack),r_和c_等类和函数用于数组拼接的操作. 各种函数的特点和区别如下标: concatenate 提供了axis参数,用于指定拼接方向 append 默认先ravel再拼接成一维数组,也可指定axis stack 提供了axis参数,用于生成新的维度 hstack 水平拼接,沿着行的方向,对列进行拼接 vstack 垂直拼接,沿着列的

  • 对numpy中shape的深入理解

    环境:Windows, Python2.7 一维情况: <span style="font-size:14px;">>>> import numpy as np >>> a = np.array([2,3,33]) >>> a array([ 2 3 33 ]) >>> print a [ 2 3 33 ] >>> a.shape (3, )</span> 一维情况中arr

  • 关于numpy中np.nonzero()函数用法的详解

    np.nonzero函数是numpy中用于得到数组array中非零元素的位置(数组索引)的函数.一般来说,通过help(np.nonzero)能够查看到该函数的解析与例程.但是,由于例程为英文缩写,阅读起来还是很费劲,因此,本文将其英文解释翻译成中文,便于理解. 解释 nonzero(a) 返回数组a中非零元素的索引值数组. (1)只有a中非零元素才会有索引值,那些零值元素没有索引值: (2)返回的索引值数组是一个2维tuple数组,该tuple数组中包含一维的array数组.其中,一维arra

  • 深入理解Python中的*重复运算符

    在python中有个特殊的符号"*",可以用做数值运算的乘法算子,也是用作对象的重复算子,但在作为重复算子使用时一定要注意 注意的是:*重复出来的各对象具有同一个id,也就是指向在内存中同一块地址,在对各个对象进行操作是一定要注意. 举例来说: >>> alist = [range(3)]*4 >>> alist [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]] 上面初始化一个二层列表用来模拟矩阵,该矩阵式4X

  • numpy中索引和切片详解

    索引和切片 一维数组 一维数组很简单,基本和列表一致. 它们的区别在于数组切片是原始数组视图(这就意味着,如果做任何修改,原始都会跟着更改). 这也意味着,如果不想更改原始数组,我们需要进行显式的复制,从而得到它的副本(.copy()). import numpy as np #导入numpy arr = np.arange(10) #类似于list的range() arr Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) arr[4] #索引(注意是从

  • Numpy中stack(),hstack(),vstack()函数用法介绍及实例

    1.stack()函数 函数原型为:stack(arrays,axis=0),arrays可以传数组和列表.axis的含义我下面会讲解,我们先来看个例子,然后我会分析输出结果. import numpy as np a=[[1,2,3], [4,5,6]] print("列表a如下:") print(a) print("增加一维,新维度的下标为0") c=np.stack(a,axis=0) print(c) print("增加一维,新维度的下标为1&qu

  • 对numpy中数组元素的统一赋值实例

    Numpy中的数组整体处理赋值操作一直让我有点迷糊,很多时候理解的不深入.今天单独列写相关的知识点,进行总结一下. 先看两个代码片小例子: 例子1: In [2]: arr =np.empty((8,4)) In [3]: arr Out[3]: array([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0.,

  • numpy中的高维数组转置实例

    numpy中的ndarray很适合数组运算 transpose是用来转置的一个函数,很容易让人困惑,其实它是对矩阵索引顺序的一次调整.原先矩阵是一个三维矩阵,索引顺序是x,y,z,角标分别是0.1.2,经过上图(1,0,2)调整后就成了y,x,z. 理解了这些,那么swapaxes方法也就不难理解了 以上这篇numpy中的高维数组转置实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们. 您可能感兴趣的文章: Numpy中转置transpose.T和swapaxes的

  • 对numpy中布尔型数组的处理方法详解

    布尔数组的操作方式主要有两种,any用于查看数组中是否有True的值,而all则用于查看数组是否全都是True. 如果用于计算的时候,布尔量会被转换成1和0,True转换成1,False转换成0.通过这种方法可以统计一个布尔量数组中True的个数. 如果普通的数组用于布尔类操作,也会有类似的数据类型转换.其中,非0的数值转换成True,而0则被转换成False. In [30]: arr = randn(100) In [31]: arr Out[31]: array([ 1.38474589,

随机推荐