np.max()、np.argmax()、np.maximum()、np.min()、np.argmin()、np.minimum()、np.sum()

最新推荐文章于 2025-03-23 10:45:40 发布
最新推荐文章于 2025-03-23 10:45:40 发布
阅读量3.6w 收藏 161
点赞数 58
文章标签： python numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41560402/article/details/105277069
版权

numpy专题——最值、求和

网上已经有很多对于这几个函数的讲解资料，但总感觉讲得有些乱，特别是对于高维数组，如果指定了某个轴，就会变得很复杂。这篇文章根据”拆分“原理，对numpy数据的这几个函数进行简单而又详细地讲解。

拆分原理：指定哪个轴，就对哪个轴进行拆分，以得到多个数组，然后对这些数组进行对应元素操作。即
假设三维numpy数组array1的shape为(c, m, n)，其中axis=0对应“c”，axis=1对应“m”，axis=2对应“n”。
若指定轴0（axis = 0），则对轴0进行拆分，得到c个shape为(m, n)的ndarray：array1[0, :, :]、array1[1, :, :]、… 、array1[c-1, :, :]，然后对array1[0, :, :]、array1[1, :, :]、… 、array1[c-1, :, :]进行对应元素操作，得到输出结果，其shape为(m, n)。其他轴类似。

如果您还没明白，请继续往下看。

最大值

np.max()、np.argmax()、np.maximum()和np.min()、np.argmin()、np.minimum()一一对应，前一组与”最大“有关，后一组与”最小“有关，所以这里只讲”最大“

np.max()

函数形式

np.max(array, axis=None, out=None, keepdims=False)

ndarray的形状是从左往右的，即由外往里计算，这和list是一样。
keepdims默认为False，如果keepdims=True，则输出的ndarray与原nadarray具有相同的形状。

  • 一维ndarray
import numpy as np

array1 = np.array([1, 3, 2, 8, 5])
print(array1)
print(np.max(array1))  # 返回array1的最大值
print(np.max(array1, axis=0))  # 指定0轴（即array1本身，输出结果一样）

输出结果：

[1 3 2 8 5]
8
8
  • 二维ndarray
    假设二维numpy数组array1的shape为(3, 4)，其中axis=0对应“3”，axis=1对应“4”
    （1）指定轴0：axis=0
    np.max(array1, axis=0)的意思就是：按第一个维度（即，行）对array1进行拆分，得到array1[0, :]、array1[1, :]、array1[2, :]，然后对array1[0, :]、array1[1, :]、array1[2, :]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。
array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[0, :] =', array1[0, :])
print('array1[1, :] =', array1[1, :])
print('array1[2, :] =', array1[2, :])
print('np.max(array1, axis=0)=', np.max(array1, axis=0))

输出结果：

array1= [[0  1  2  3]
         [4  5  6  7]
         [8  9 10 11]]
array1[0, :] = [0 1 2 3]
array1[1, :] = [4 5 6 7]
array1[2, :] = [8 9 10 11]
np.max(array1, axis=0) = [8 9 10 11]

（2）指定轴1：axis=1
np.max(array1, axis=1)的意思就是：按第二个维度（即，列）对array1进行拆分，得到array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]，然后对array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[:, 0] =', array1[:, 0])
print('array1[:, 1] =', array1[:, 1])
print('array1[:, 2] =', array1[:, 2])
print('array1[:, 3] =', array1[:, 3])
print('np.max(array1, axis=1) =', np.max(array1, axis=1))

输出结果：

array1 = [[0  1  2  3]
          [4  5  6  7]
          [8  9 10 11]]
array1[:, 0] = [0 4 8]
array1[:, 1] = [1 5 9]
array1[:, 2] = [2 6 10]
array1[:, 3] = [3 7 11]
np.max(array1, axis=1) = [3 7 11]
  • 三维ndarray
    假设三维numpy数组array1的shape为(2, 3, 4)，其中axis=0对应“2”，axis=1对应“3”，axis=2对应“4”。
    （1）指定轴0：axis=0
    np.max(array1, axis=0)的意思就是：按第一个维度对array1进行拆分，得到array1[0, :, :]、array1[1, :, :]，然后对array1[0, :, :]、array1[1, :, :]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。
import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[0, :, :] =', array1[0, :, :])
print('array1[1, :, :] =', array1[1, :, :])
print('np.max(array1, axis=0) =', np.max(array1, axis=0))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[0, :, :] = [[0  1  2  3]
                   [4  5  6  7]
                   [8  9 10 11]]
array1[1, :, :] = [[12 13 14 15]
                   [16 17 18 19]
                   [20 21 22 23]]
np.max(array1, axis=0) = [[12 13 14 15]
                          [16 17 18 19]
                          [20 21 22 23]]

（2）指定轴1：axis=1
np.max(array1, axis=1)的意思就是：按第二个维度对array1进行拆分，得到array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]，然后对array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, 0, :] =', array1[:, 0, :])
print('array1[:, 1, :] =', array1[:, 1, :])
print('array1[:, 2, :] =', array1[:, 2, :])
print('np.max(array1, axis=1) =', np.max(array1, axis=1))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, 0, :] = [[ 0  1  2  3]
                   [12 13 14 15]]
array1[:, 1, :] = [[ 4  5  6  7]
                   [16 17 18 19]]
array1[:, 2, :] = [[ 8  9 10 11]
                   [20 21 22 23]]
np.max(array1, axis=1) = [[ 8  9 10 11]
                          [20 21 22 23]]

（3）指定轴2：axis=2
np.max(array1, axis=2)的意思就是：按第三个维度对array1进行拆分，得到array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]，然后对array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, :, 0] =', array1[:, :, 0])
print('array1[:, :, 1] =', array1[:, :, 1])
print('array1[:, :, 2] =', array1[:, :, 2])
print('array1[:, :, 3] =', array1[:, :, 3])
print('np.max(array1, axis=2) =', np.max(array1, axis=2))

输出结果：

array1 = [[[0  1  2  3]
 		   [4  5  6  7]
		   [8  9 10 11]]

 		  [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, :, 0] = [[ 0  4  8]
                   [12 16 20]]
array1[:, :, 1] = [[ 1  5  9]
                   [13 17 21]]
array1[:, :, 2] = [[ 2  6 10]
                   [14 18 22]]
array1[:, :, 3] = [[ 3  7 11]
                   [15 19 23]]
np.max(array1, axis=2) = [[ 3  7 11]
                          [15 19 23]]

np.argmax()

np.argmax()与np.max()类似：np.max()返回指定轴的最大值，而np.argmax()返回指定轴的最大值对应的索引，指定哪个轴，就按哪个轴进行拆分。

  • 一维ndarray
import numpy as np

array1 = np.array([1, 3, 2, 8, 5])
print(array1)
print(np.argmax(array1))  # 返回array1的最大值对应的索引
print(np.argmax(array1, axis=0))  # 指定0轴（即array1本身，输出结果一样）

输出结果：

[1 3 2 8 5]
3
3
  • 二维ndarray
    假设二维numpy数组array1的shape为(3, 4)，其中axis=0对应“3”，axis=1对应“4”
    （1）指定轴0：axis=0
    np.argmax(array1, axis=0)的意思就是：按第一个维度（即，行）对array1进行拆分，得到array1[0, :]、array1[1, :]、array1[2, :]，然后对array1[0, :]、array1[1, :]、array1[2, :]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1[0, :]，则返回索引0,；若某一对应元素的最大值在array1[1, :]，则返回索引1；依此类推），构成新的ndarray。
import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[0, :] =', array1[0, :])
print('array1[1, :] =', array1[1, :])
print('array1[2, :] =', array1[2, :])
print('np.max(array1, axis=0)=', np.max(array1, axis=0))

输出结果：

array1= [[0  1  2  3]
         [4  5  6  7]
         [8  9 10 11]]
array1[0, :] = [0 1 2 3]
array1[1, :] = [4 5 6 7]
array1[2, :] = [8 9 10 11]
np.argmax(array1, axis=0)= [2 2 2 2]

（2）指定轴1：axis=1
np.arg(array1, axis=1)的意思就是：按第二个维度（即，列）对array1进行拆分，得到array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]，然后对array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1[:, 0]，则返回索引0,；若某一对应元素的最大值在array1[:, 1]，则返回索引1；依此类推），构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[:, 0] =', array1[:, 0])
print('array1[:, 1] =', array1[:, 1])
print('array1[:, 2] =', array1[:, 2])
print('array1[:, 3] =', array1[:, 3])
print('np.argmax(array1, axis=1) =', np.argmax(array1, axis=1))

输出结果：

array1 = [[0  1  2  3]
          [4  5  6  7]
          [8  9 10 11]]
array1[:, 0] = [0 4 8]
array1[:, 1] = [1 5 9]
array1[:, 2] = [2 6 10]
array1[:, 3] = [3 7 11]
np.argmax(array1, axis=1) = [3 3 3]

（3）没有指定任何轴

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
array1[2, 3] = 1
print('array1 =', array1)
print('np.argmax(array1) =', np.argmax(array1))

输出结果：

array1 = [[ 0  1  2  3]
          [ 4  5  6  7]
          [ 8  9 10  1]]
np.argmax(array1) = 10

由于Numpy是按维度大小的顺序由最底层开始存储的，所以 m × n m \times n m×n 的ndarray最大值的索引是：(np.argmax(array1) // n, np.argmax(array1) % n)。

  • 三维ndarray
    假设三维numpy数组array1的shape为(2, 3, 4)，其中axis=0对应“2”，axis=1对应“3”，axis=2对应“4”。
    （1）指定轴0：axis=0
    np.argmax(array1, axis=0)的意思就是：按第一个维度对array1进行拆分，得到array1[0, :, :]、array1[1, :, :]，然后对array1[0, :, :]、array1[1, :, :]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1[0, :, :]，则返回索引0,；若某一对应元素的最大值在[1, :, :]，则返回索引1；依此类推），构成新的ndarray。
import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[0, :, :] =', array1[0, :, :])
print('array1[1, :, :] =', array1[1, :, :])
print('np.argmax(array1, axis=0) =', np.argmax(array1, axis=0))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[0, :, :] = [[0  1  2  3]
                   [4  5  6  7]
                   [8  9 10 11]]
array1[1, :, :] = [[12 13 14 15]
                   [16 17 18 19]
                   [20 21 22 23]]
np.argmax(array1, axis=0) = [[1 1 1 1]
 							 [1 1 1 1]
 							 [1 1 1 1]]

（2）指定轴1：axis=1
np.argmax(array1, axis=1)的意思就是：按第二个维度对array1进行拆分，得到array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]，然后对array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1array1[:, 0, :]，则返回索引0,；若某一对应元素的最大值在[:, 1, :]，则返回索引1；依此类推），构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, 0, :] =', array1[:, 0, :])
print('array1[:, 1, :] =', array1[:, 1, :])
print('array1[:, 2, :] =', array1[:, 2, :])
print('np.argmax(array1, axis=1) =', np.argmax(array1, axis=1))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, 0, :] = [[ 0  1  2  3]
                   [12 13 14 15]]
array1[:, 1, :] = [[ 4  5  6  7]
                   [16 17 18 19]]
array1[:, 2, :] = [[ 8  9 10 11]
                   [20 21 22 23]]
np.argmax(array1, axis=1) = [[2 2 2 2]
           					 [2 2 2 2]]

（3）指定轴2：axis=2
np.argmax(array1, axis=2)的意思就是：按第三个维度对array1进行拆分，得到array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]，然后对array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1array1[:, :, 0]，则返回索引0,；若某一对应元素的最大值在[:, :, 1]，则返回索引1；依此类推），构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, :, 0] =', array1[:, :, 0])
print('array1[:, :, 1] =', array1[:, :, 1])
print('array1[:, :, 2] =', array1[:, :, 2])
print('array1[:, :, 3] =', array1[:, :, 3])
print('np.argmax(array1, axis=2) =', np.argmax(array1, axis=2))

输出结果：

array1 = [[[0  1  2  3]
 		   [4  5  6  7]
		   [8  9 10 11]]

 		  [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, :, 0] = [[ 0  4  8]
                   [12 16 20]]
array1[:, :, 1] = [[ 1  5  9]
                   [13 17 21]]
array1[:, :, 2] = [[ 2  6 10]
                   [14 18 22]]
array1[:, :, 3] = [[ 3  7 11]
                   [15 19 23]]
np.argmax(array1, axis=2) = [[3 3 3]
                             [3 3 3]]

np.maximum()

np.maximum(array1, array2)：逐位比较array1和array2，并输出两者的最大值。

  • 如果array1和array2的形状相同，则输出结果的形状与array1和array2的形状相同。
  • 如果array1和array2的形状不同（允许只有一个维度不同），则会用到numpy的broadcast机制。
  • 如果用于比较的ndarray有一个是标量，则另一个ndarray可以是任何形状，这同样用到了broadcast机制
import numpy as np

array1 = np.array([[2, 5, 8], [3, 4, 6]])
array2 = np.array([[3, 4, 9], [2, 1, 6]])
array3 = np.array([1, 6, 7])
print('array1 =', array1)
print('array2 =', array2)
print('array3 =', array3)
print('np.maximum(array1, array2) =', np.maximum(array1, array2))
print('np.maximum(array1, array3) =', np.maximum(array1, array3))  # numpy的broadcast机制
print('np.maximum(array1, 4) =', np.maximum(array1, 4))  # numpy的broadcast机制

输出结果：

array1 = [[2 5 8]
          [3 4 6]]
array2 = [[3 4 9]
          [2 1 6]]
array3 = [1 6 7]
np.maximum(array1, array2) = [[3 5 9]
                              [3 4 6]]
np.maximum(array1, array3) = [[2 6 8]
							  [3 6 7]]
np.maximum(array1, 4) = [[4 5 8]
 						 [4 4 6]]

求和

np.sum

  1. 一维ndarray
    对所有元素求和（无论多少维的ndarray，只要没有指定axis，就表示对所有元素进行求和）。
import numpy as np

array1 = np.array([1, 3, 2, 8, 5])
print(array1)
print(np.sum(array1))  # 返回对array1的所有元素进行求和
print(np.sum(array1, axis=0))  # 指定0轴（即array1本身，输出结果一样）
  1. 二维ndarray
    假设二维numpy数组array1的shape为(3, 4)，其中axis=0对应“3”，axis=1对应“4”
    （1）指定轴0：axis=0
    np.sum(array1, axis=0)的意思就是：按第一个维度（即，行）对array1进行拆分，得到array1[0, :]、array1[1, :]、array1[2, :]，然后对array1[0, :]、array1[1, :]、array1[2, :]的对应元素进行逐位相加，构成新的ndarray。即
    np.sum(array1, axis=0) = array1[0, :] + array1[1, :] + array1[2, :]
import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[0, :] =', array1[0, :])
print('array1[1, :] =', array1[1, :])
print('array1[2, :] =', array1[2, :])
print('np.sum(array1, axis=0)=', np.sum(array1, axis=0))

输出结果：

array1= [[0  1  2  3]
         [4  5  6  7]
         [8  9 10 11]]
array1[0, :] = [0 1 2 3]
array1[1, :] = [4 5 6 7]
array1[2, :] = [8 9 10 11]
np.sum(array1, axis=0)= [12 15 18 21]

（2）指定轴1：axis=1
np.sum(array1, axis=1)的意思就是：按第二个维度（即，列）对array1进行拆分，得到array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]，然后对array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]的对应元素进行逐位相加，构成新的ndarray。即
np.sum(array1, axis=1) = array1[:, 0] + array1[:, 1] + array1[:, 2] + array1[:, 3]

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[:, 0] =', array1[:, 0])
print('array1[:, 1] =', array1[:, 1])
print('array1[:, 2] =', array1[:, 2])
print('array1[:, 3] =', array1[:, 3])
print('np.sum(array1, axis=1) =', np.sum(array1, axis=1))

输出结果：

array1 = [[0  1  2  3]
          [4  5  6  7]
          [8  9 10 11]]
array1[:, 0] = [0 4 8]
array1[:, 1] = [1 5 9]
array1[:, 2] = [2 6 10]
array1[:, 3] = [3 7 11]
np.sum(array1, axis=1) = [6 22 38]
  1. 三维ndarray
    假设三维numpy数组array1的shape为(2, 3, 4)，其中axis=0对应“2”，axis=1对应“3”，axis=2对应“4”。
    （1）指定轴0：axis=0
    np.sum(array1, axis=0)的意思就是：按第一个维度对array1进行拆分，得到array1[0, :, :]、array1[1, :, :]，然后对array1[0, :, :]、array1[1, :, :]的对应元素进行逐位相加，构成新的ndarray，即
    np.sum(array1, axis=0) = array1[0, :, :] + array1[1, :, :]
import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[0, :, :] =', array1[0, :, :])
print('array1[1, :, :] =', array1[1, :, :])
print('np.sum(array1, axis=0) =', np.sum(array1, axis=0))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[0, :, :] = [[0  1  2  3]
                   [4  5  6  7]
                   [8  9 10 11]]
array1[1, :, :] = [[12 13 14 15]
                   [16 17 18 19]
                   [20 21 22 23]]
np.sum(array1, axis=0) = [[12 14 16 18]
                          [20 22 24 26]
                          [28 30 32 34]]

（2）指定轴1：axis=1
npsum(array1, axis=1)的意思就是：按第二个维度对array1进行拆分，得到array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]，然后对array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]的对应元素进行逐位相加，构成新的ndarray，即
np.sum(array1, axis=1) = array1[:, 0, :] + array1[:, 1, :] + array1[:, 2, :]

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, 0, :] =', array1[:, 0, :])
print('array1[:, 1, :] =', array1[:, 1, :])
print('array1[:, 2, :] =', array1[:, 2, :])
print('np.sum(array1, axis=1) =', np.sum(array1, axis=1))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, 0, :] = [[ 0  1  2  3]
                   [12 13 14 15]]
array1[:, 1, :] = [[ 4  5  6  7]
                   [16 17 18 19]]
array1[:, 2, :] = [[ 8  9 10 11]
                   [20 21 22 23]]
np.sum(array1, axis=1) = [[12 15 18 21]
 				          [48 51 54 57]]

（3）指定轴2：axis=2
np.sum(array1, axis=2)的意思就是：按第三个维度对array1进行拆分，得到array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]，然后对array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]的对应元素进行逐位相加，构成新的ndarray，即
np.sum(array1, axis=2) = array1[:, :, 0] + array1[:, :, 1] + array1[:, :, 2] + array1[:, :, 3]

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, :, 0] =', array1[:, :, 0])
print('array1[:, :, 1] =', array1[:, :, 1])
print('array1[:, :, 2] =', array1[:, :, 2])
print('array1[:, :, 3] =', array1[:, :, 3])
print('np.sum(array1, axis=2) =', np.sum(array1, axis=2))

输出结果：

array1 = [[[0  1  2  3]
 		   [4  5  6  7]
		   [8  9 10 11]]

 		  [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, :, 0] = [[ 0  4  8]
                   [12 16 20]]
array1[:, :, 1] = [[ 1  5  9]
                   [13 17 21]]
array1[:, :, 2] = [[ 2  6 10]
                   [14 18 22]]
array1[:, :, 3] = [[ 3  7 11]
                   [15 19 23]]
np.sum(array1, axis=2) = [[ 6 22 38]
                          [54 70 86]]
dekiang
关注
理解np.max、np.min、np.argmax、np.argmin以及np.sum中的axis参数
冰糖麻辣鱼的博客
12-30 2402
理解numpy数组中沿轴求最值，求和 假设我们的数组共有0、1、2、3四维（分别代表着不同含义，可参考自己的数据进行替换），三个函数的含义分别为： 直接举例子 import numpy as np np.max(axis=C) # 同A、同B、同D，在不同C中元素值最大是多少 np.argmax(axis=C) # 同A、同B、同D，在不同C中元素值最大的 是哪个C np.min() n...
np.max()， np.maximum()， np.argmax()
Gfqwy2021
11-09 5381
np.max：接受一个参数，返回对应的最大值； np.argmax：接受一个参数，返回最大值对应的索引； np.maximum：接受两个参数，对应数学中的max操作 import numpy as np a = [-10, -3, -2, 0, 7, 2, 3] b = np.max(a) c = np.argmax(a) d = np.maximum(0, a) a Out[1]: [-1...
np.max 与 np.maximum
热门推荐
09-29 10万+
1. 参数 2. 使用上
Python NumPy常用函数详解：从入门到实战（附代码示例）
2403_87579853的博客
03-23 730
掌握上述函数后，你可以：快速创建和操作多维数组实现高效的数学计算与统计分析处理矩阵运算和随机数生成学习建议在Jupyter Notebook中逐行运行示例代码尝试修改参数观察结果变化结合实际项目（如数据处理、图像变换）加深理解扩展阅读NumPy官方文档《Python数据分析基础教程：NumPy学习指南》文章说明：本文代码均在 NumPy 1.24+ 环境下测试通过。
Numpy中np.max()和np.min()用法
weixin_44558721的博客
10-19 7160
PyTorch基础知识
解析np.max
Darlewo
11-11 1万+
首先看np.max函数返回为 Return the maximum of an array or maximum along an axis 一个是数组的最大值，另一个是沿着轴的最大值。首先一个数组的最大值好理解，主要是沿着某个轴的最大值怎么求，最后得到的形状是什么? 那我们首先生成一个数组，形状为[2, 3, 4],我们分别返回沿着0， 1， 2三个轴返回其最大值，我们看返回后的形状分别为...
np.maximum()
这个人很蓝
04-12 2万+
np.maximum(X, Y) 用于逐元素比较两个array的大小。 import numpy as np X = np.array([1, 2, 3, 4]) Y = np.array([4, 3, 1, 3]) print(np.maximum(X, Y)) >>> [4 3 3 4]
numpy.maximum和 numpy.argmax的使用小记
Soly_semon的博客
03-06 369
作用： 按元素比较两个列表，返回包含最大值的列表。 参数：x1,x2 是两个待比较的列表。如果x1.shape!=x2.shape 则进行广播操作然后再比较。 例子： np.maximum([2, 3, 4], [1, 5, 2]) array([2, 5, 4]) np.maximum(np.eye(2), [0.5, 2]) # broadcasting ar...
pythonabs_Python numpy.abs() 使用实例
weixin_39702480的博客
11-25 1809
The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can al...
AI：Numpy的多维数组ndarray的基本使用
程序员无羡的博客
04-26 641
AI：Numpy的多维数组ndarray的基本使用
Python科学计算包NumPy教程
ly's Blog
07-16 626
在我的Github上有一份代码与教程结合的jupyter Notebook文件，大家可以clone下来看一看。 下面会用实例的方式给出一些examples： Tutorial教程 官方中文文档 import numpy as np # 创建数组： array1 = np.array([1, 2, 3]) # 创建一个一维数组，只有一个轴，轴的长度为3 print(array1) # 通过列表创建二维数组： print(np.array([(1, 2, 3), (4, 5, 6)])) # 2x3的数组
np.argmax()函数用法解析——通俗易懂
12-22
目录 简介 一维数组用法 多维数组用法 二维 高维 0. 简介 numpy.argmax(array, axis) 用于返回一个numpy数组中最大值的索引值。当一组中同时出现几个最大值时，返回第一个最大值的索引值。 在运算时，相当于剥掉一层中括号，返回一个数组，分为一维和多维。一维数组剥掉一层中括号之后就成了一个索引值，是一个数，而n维数组剥掉一层中括号后，会返回一个 n-1 维数组，而剥掉哪一层中括号，取决于axis的取值。 n维的数组的 axis 可以取值从 0 到 n-1，其对应的括号层数为从最外层向内递进，详见后文。 一、一维数组的用法 one_dim_array = np.arra
【Python基础知识库】Numpy库里有哪些函数？
holysll的博客
04-19 2346
NumPy是Numerical Python的简称，是目前python高性能科学计算和数据分析中最为重要的基础包。 ndarray, 具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组。 用于对整组数据进行快速运算的标准数学函数（无需编写循环）。 用于读写磁盘数据的工具以及用于操作内存映射文件的工具。 线性代数、随机数生成以及傅里叶变换功能。 用于集成C、C++、Fortr...
Numpy中np.max(即np.amax)的用法
我就吃一口的BLOG
11-25 9万+
Numpy中np.max(即np.amax)的用法 >>> import numpy as np >>> help(np.max) 当遇到一个不认识的函数，我们就需要查看一下帮助文档 np.max与np.amax是同名函数 amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>) Return the .
python np.max怎么用
hakesashou的博客
07-31 784
语法：np.max：(a, axis=None, out=None, keepdims=False)axis：默认为列向（也即 axis=0），axis = 1 时为行方向的最值。
np.argmax()和max()助解
MasterCayman的博客
08-07 779
一、argmax() argmax取最大值，然后返回索引。 (1)一维向量 import numpy as np a = np.array([3, 1, 2, 4, 6, 1]) res = np.argmax(a) print(res) 取a中元素最大值所对应的索引（索引默认从0开始），此时的最大值是6，其对应的位置索引值为4。 （2）二维张量 a = np.array([[1, 5, 5, 2], [9, 6, 2, 8], [3
np.maximum()函数详解——将数组中小于某值的数用0代替
Smile@小女子的博客
11-08 1万+
目标：把数组中小于某个值的数都设为0。 np.max(a, axis=None, out=None, keepdims=False) 求a中的最大值 np.maximum：(a, b, out=自定义) a 与 b 逐位比较取其大者； import numpy as np data1 = [] #省略 data = np.maximum(data1，0.) #省略 ...
np.argmax()和np.max()的区别
YHKKun的博客
04-08 421
给出的是最大值在数组中的位置（索引）。给出的是数组中的最大值本身，而。
``` class GradCAMpp: def __init__(self, model, target_layer): self.model = model self.target_layer = target_layer self.activations = None self.gradients = None # 注册前向传播和反向传播钩子 target_layer.register_forward_hook(self.save_activation) target_layer.register_backward_hook(self.save_gradient) def save_activation(self, module, input, output): self.activations = output.detach() def save_gradient(self, module, grad_input, grad_output): self.gradients = grad_output[0].detach() def __call__(self, input_tensor, class_idx=None): # 前向传播 self.model.eval() output = self.model(input_tensor) if class_idx is None: class_idx = output.argmax(dim=1) # 反向传播 self.model.zero_grad() one_hot = torch.zeros_like(output) one_hot[0][class_idx] = 1.0 output.backward(gradient=one_hot) # 计算权重 grad = self.gradients[0].numpy() act = self.activations[0].numpy() # Grad-CAM++核心计算 grad_power = grad ** 2 grad_power_times_act = grad_power * act weights = grad_power_times_act / (2 * grad_power_times_act + np.sum(act * grad_power_times_act, axis=(1,2), keepdims=True)) weights = np.sum(weights, axis=(1,2)) # 生成热力图 cam = np.zeros(act.shape[1:], dtype=np.float32) for i, w in enumerate(weights): cam += w * act[i] cam = np.maximum(cam, 0) cam = cv2.resize(cam, (224, 224)) cam = cam - np.min(cam) cam = cam / np.max(cam) return cam # 获取目标层（使用最后一个卷积层） target_layer = model.conv2 # 创建Grad-CAM++实例 gradcam_pp = GradCAMpp(model, target_layer) # 反标准化函数 def denormalize(tensor): mean = torch.tensor([0.5, 0.5, 0.5]) std = torch.tensor([0.5, 0.5, 0.5]) return tensor * std.view(3, 1, 1) + mean.view(3, 1, 1) # 可视化示例 num_samples = 3 # 可视化样本数量 fig, axes = plt.subplots(num_samples, 3, figsize=(15, 10)) for idx in range(num_samples): # 获取测试样本 img, label = test_dataset[idx] input_tensor = img.unsqueeze(0) # 获取预测结果 with torch.no_grad(): output = model(input_tensor) pred_class = output.argmax().item() # 生成热力图 cam = gradcam_pp(input_tensor, pred_class) # 处理原始图像 img_denorm = denormalize(img).permute(1, 2, 0).numpy() # 绘制结果 axes[idx, 0].imshow(img_denorm) axes[idx, 0].axis('off') axes[idx, 0].set_title(f'Original (True: {full_dataset.classes[label]})') axes[idx, 1].imshow(cam, cmap='jet') axes[idx, 1].axis('off') axes[idx, 1].set_title(f'Grad-CAM++ Heatmap (Pred: {full_dataset.classes[pred_class]})') axes[idx, 2].imshow(img_denorm) axes[idx, 2].imshow(cam, cmap='jet', alpha=0.5) axes[idx, 2].axis('off') axes[idx, 2].set_title('Overlay') plt.tight_layout() plt.show()```Warning (from warnings module): File "C:\Users\29930\AppData\Local\Programs\Python\Python311\Lib\site-packages\torch\nn\modules\module.py", line 1830 self._maybe_warn_non_full_backward_hook(args, result, grad_fn) FutureWarning: Using a non-full backward hook when the forward contains multiple autograd Nodes is deprecated and will be removed in future versions. This hook will be missing some grad_input. Please use register_full_backward_hook to get the documented behavior. Warning (from warnings module): File "D:/正式建模/CNN+++.py", line 150 weights = grad_power_times_act / (2 * grad_power_times_act + RuntimeWarning: invalid value encountered in divide
最新发布
03-30
<think>好的，我现在需要帮助用户解决他们提供的Python代码中的警告问题。首先，我得仔细看看用户提供的代码和出现的警告信息。 用户代码中的GradCAMpp类使用了register_backward_hook，而PyTorch发出了FutureWarning，指出非完整反向钩子在包含多个autograd节点的前向传播中被弃用，建议使用register_full_backward_hook。同时，在计算权重时出现了除以零的RuntimeWarning，导致无效值。 首先，处理第一个关于反向钩子的警告。根据PyTorch文档，非完整钩子可能无法正确捕获所有梯度输入，特别是当模块有多个输入或输出时。用户原来的save_gradient方法接收grad_input和grad_output，但旧版钩子可能无法正确传递梯度。因此，应该将register_backward_hook替换为register_full_backward_hook，并调整保存梯度的方式。注意，register_full_backward_hook的参数是module, grad_input, grad_output，但需要返回修改后的grad_input，不过在这里可能不需要修改，只需保存grad_output即可。但需要检查参数顺序是否正确。在原来的钩子中，grad_output可能是一个元组，所以可能需要取grad_output[0]。不过，可能需要测试一下。 接下来处理第二个警告，RuntimeWarning: divide。这可能是因为分母中有零，导致除法出现无效值。在计算weights时，分母是2 * grad_power_times_act + sum(...)。如果分母中的某些元素为零，就会导致除以零的情况。例如，当梯度或激活值全为零时，分母可能为零。这时候需要添加一个小的epsilon（例如1e-10）到分母中，避免除以零的情况。或者在计算时检查分母是否为零，进行相应处理。 然后，针对用户代码中的具体实现： 在GradCAMpp的__init__中，注册钩子的方式可能需要修改。原来的register_backward_hook被替换为register_full_backward_hook。但需要注意，register_full_backward_hook的参数是否和原来的钩子兼容。根据PyTorch文档，register_full_backward_hook的参数是hook(module, grad_input, grad_output)，而原来的register_backward_hook在旧版本中的行为可能不同。因此，修改注册钩子的方式，同时可能需要调整保存梯度的部分。例如，原来的save_gradient方法接收grad_output[0]，但使用register_full_backward_hook后，是否grad_output的结构有变化？ 另外，关于权重计算部分，原来的代码： weights = grad_power_times_act / (2 * grad_power_times_act + np.sum(act * grad_power_times_act, axis=(1,2), keepdims=True)) 这里的分母可能为零，导致除法无效。解决方法是在分母中添加一个极小值epsilon，例如： denominator = (2 * grad_power_times_act + np.sum(act * grad_power_times_act, axis=(1,2), keepdims=True)) + 1e-10 weights = grad_power_times_act / denominator 这样即使分母为零，也能避免除以零的情况。 接下来，测试修改后的代码是否解决了这两个警告。对于钩子的替换，可能需要检查是否正确捕获了梯度。原来的钩子保存的是grad_output[0]，而使用register_full_backward_hook后，是否grad_output的结构相同？可能需要打印grad_output的形状来验证，或者在文档中查找register_full_backward_hook的返回值结构。 另一个可能的问题是，在反向钩子中，是否应该保存grad_input或grad_output。Grad-CAM通常需要目标层的梯度相对于输出的梯度。可能需要确认在反向传播中，目标层的梯度输出是哪个部分。例如，对于卷积层，grad_output可能是相对于该层输出的梯度。因此，正确的梯度应该来自grad_output，而非grad_input。因此，在save_gradient方法中，保存grad_output[0]可能是正确的，但需要确保使用register_full_backward_hook时，grad_output的结构是否变化。 此外，用户提到的警告中，PyTorch指出使用非完整反向钩子的问题，而推荐使用register_full_backward_hook。因此，替换钩子应该可以解决第一个警告。对于第二个警告，添加epsilon即可。 总结修改步骤： 1. 在注册反向钩子时，使用register_full_backward_hook代替register_backward_hook。 修改代码： 将 target_layer.register_backward_hook(self.save_gradient) 改为 target_layer.register_full_backward_hook(self.save_gradient) 不过，需要查看PyTorch版本是否支持。register_full_backward_hook在PyTorch 1.8.0及以上版本中可用。如果用户的PyTorch版本较低，可能需要升级，或者调整钩子的实现。 但根据用户的警告信息，他们使用的是Python 3.11，可能PyTorch版本较新，所以应该支持。 然后，在save_gradient方法中，可能需要调整参数的顺序或者如何处理grad_output。原来的钩子可能接收grad_input和grad_output的顺序不同，但根据PyTorch文档，register_full_backward_hook的参数顺序是module, grad_input, grad_output。因此，原来的save_gradient方法中的参数是module, grad_input, grad_output，而之前用户代码中的save_gradient接收的是grad_output[0]。所以应该保持不变，因为grad_output是相对于该层的输出梯度，而原来的代码保存的是grad_output[0].detach()。所以修改后的钩子应该仍然正确。 接下来，处理RuntimeWarning。在计算分母时添加epsilon： 修改分母的计算： weights = grad_power_times_act / (2 * grad_power_times_act + np.sum(act * grad_power_times_act, axis=(1,2), keepdims=True) + 1e-10) 或者使用np.maximum来确保分母不为零。 此外，可能还需要检查其他部分是否有潜在的问题，例如输入数据是否正常，梯度是否存在NaN等。 总结，用户的代码需要两个主要修改：替换反向钩子的注册方法，并在分母中添加小量防止除以零。</think>让我们分步分析并解决代码中的警告问题： ### 一、警告原因分析 #### 1. `FutureWarning` 警告 $$ \text{原因：} \quad \text{PyTorch 1.8+ 弃用非完整反向钩子} $$ $$ \text{影响：} \quad \text{梯度可能捕获不全，导致CAM计算错误} $$ #### 2. `RuntimeWarning` 警告 $$ \text{原因：} \quad \frac{0}{0} \text{型无效计算} $$ $$ \text{来源：} \quad \text{梯度幅值过小导致分母趋近于零} $$ ### 二、解决方案 #### 1. 更新反向传播钩子注册方式 ```python # 修改前（旧方法） target_layer.register_backward_hook(self.save_gradient) # 修改后（新规范） target_layer.register_full_backward_hook(self.save_gradient) ``` #### 2. 增强数值稳定性 ```python # 修改前（存在除零风险） weights = grad_power_times_act / (2 * grad_power_times_act + np.sum(act * grad_power_times_act, axis=(1,2), keepdims=True)) # 修改后（添加极小值保护） epsilon = 1e-10 denominator = (2 * grad_power_times_act + np.sum(act * grad_power_times_act, axis=(1,2), keepdims=True)) + epsilon weights = grad_power_times_act / denominator ``` ### 三、完整修正代码 ```python class GradCAMpp: def __init__(self, model, target_layer): self.model = model self.target_layer = target_layer self.activations = None self.gradients = None # 使用新版钩子注册方法 target_layer.register_forward_hook(self.save_activation) target_layer.register_full_backward_hook(self.save_gradient) # 修改处 def save_activation(self, module, input, output): self.activations = output.detach() def save_gradient(self, module, grad_input, grad_output): self.gradients = grad_output[0].detach() # 保持梯度提取方式 def __call__(self, input_tensor, class_idx=None): self.model.eval() output = self.model(input_tensor) if class_idx is None: class_idx = output.argmax(dim=1) self.model.zero_grad() one_hot = torch.zeros_like(output) one_hot[0][class_idx] = 1.0 output.backward(gradient=one_hot) grad = self.gradients[0].numpy() act = self.activations[0].numpy() # 添加数值稳定性保护 epsilon = 1e-10 # 修改处 grad_power = grad ** 2 grad_power_times_act = grad_power * act denominator = (2 * grad_power_times_act + np.sum(act * grad_power_times_act, axis=(1,2), keepdims=True)) + epsilon # 修改处 weights = grad_power_times_act / denominator cam = np.zeros(act.shape[1:], dtype=np.float32) for i, w in enumerate(weights): cam += w * act[i] cam = np.maximum(cam, 0) cam = cv2.resize(cam, (224, 224)) cam = (cam - np.min(cam)) / (np.max(cam) + epsilon) # 二次保护 return cam ``` ### 四、修改效果验证 1. **梯度捕获完整性** 使用`register_full_backward_hook`后，能正确捕获到完整梯度张量，保证权重计算的准确性。 2. **数值稳定性验证** 添加$\epsilon = 10^{-10}$后，当梯度幅值小于$10^{-5}$时： $$ \frac{\text{分子}}{10^{-10}} \leq 10^{5} \quad \text{（数值在安全范围内）} $$ ### 五、可视化建议 可在权重计算后添加有效性检查： ```python assert not np.isnan(cam).any(), "CAM计算出现异常值" ```
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值