哪里写的不好请您告诉我，谢谢！

NumPy 是 Python 科学计算中一个很重要的库，其为数组处理、矩阵运算等提供了高效的操作，是深度学习模型背后计算的核心组件之一。深度学习模型的参数、权重、激活值等，常常都以 NumPy 数组的形式存储和操作。

1.  简介

NumPy (Numerical Python) 是 Python 科学计算库，它提供了对多维数组的支持，拥有高效的数组计算、矩阵运算等功能。对于深度学习来说，NumPy 是处理数据、实现前向传播、计算损失和梯度等操作的重要工具

首先进行numpy的安装：

pip install numpy

2. 创建 NumPy 数组

NumPy 的核心是 ndarray（N 维数组）对象

import numpy as np

# 创建一个 1D 数组
arr_1d = np.array([1, 2, 3, 4, 5])
print(arr_1d)

# 创建一个 2D 数组
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr_2d)

输出显示：

[1 2 3 4 5]
[[1 2 3]
 [4 5 6]]

numpy创建特殊数组：
零数组

zero_arr = np.zeros((3, 3))
print(zero_arr)

输出：

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

全一数组：

ones_arr = np.ones((2, 3))
print(ones_arr)

输出：

[[1. 1. 1.]
 [1. 1. 1.]]

随机数组：

random_arr = np.random.rand(3, 3)
print(random_arr)

3. 数组的基本操作

NumPy 提供了许多针对数组的高效操作。我们可以对数组进行算术运算、矩阵操作等

可以对数组的每个元素执行加、减、乘、除：

arr = np.array([1, 2, 3, 4])
print(arr + 2)  # 所有元素加 2
print(arr * 3)  # 所有元素乘 3

输出：

[3 4 5 6]
[3 6 9 12]

dot() 函数进行矩阵乘法：

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵乘法
C = np.dot(A, B)
print(C)

输出：

[[19 22]
 [43 50]]

 关于 axis ：

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 沿着第 0 轴（即每列）求和
print(np.sum(arr, axis=0))  # 输出: [5 7 9]

# 沿着第 1 轴（即每行）求和
print(np.sum(arr, axis=1))  # 输出: [ 6 15]

补充解释：

• axis=0 表示对列操作，沿着行的方向计算
• axis=1 表示对行操作，沿着列的方向计算

4. 数组的形状与变形

查看数组形状：

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.shape)  # 输出: (2, 3)

改变数组形状：reshape() 方法将数组的形状从一个维度变换为另一个维度（但是需要总元素数不变）

arr = np.array([1, 2, 3, 4, 5, 6])
reshaped_arr = arr.reshape((2, 3))
print(reshaped_arr)

输出：

[[1 2 3]
 [4 5 6]]

5. 在深度学习中的应用

前向传播的实现

在一个简单的神经网络中，前向传播的过程可以使用 NumPy 实现。假设我们有一个输入向量 x 和一个权重矩阵 W，前向传播（以后会写）的公式为：

                                                              z=W⋅x+b

# 输入向量 x (3 x 1)
x = np.array([1, 2, 3])

# 权重矩阵 W (2 x 3)
W = np.array([[0.2, 0.4, 0.6], [0.1, 0.3, 0.5]])

# 偏置向量 b (2 x 1)
b = np.array([0.1, 0.2])

# 前向传播计算 z = W · x + b
z = np.dot(W, x) + b
print(z)

输出：

[3.1 2.3]

激活函数

神经网络中的激活函数可以用 NumPy 实现
这里用sigmoid 激活函数来举例：
                 ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        
有水印看不请，下面是1+e^-z

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

z = np.array([0.5, 0.0, -0.5])
print(sigmoid(z))

输出：

[0.62245933 0.5        0.37754067]

损失函数

def cross_entropy_loss(y_true, y_pred):
    return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

# 假设真实值 y_true 和预测值 y_pred
y_true = np.array([1, 0, 1])
y_pred = np.array([0.8, 0.3, 0.7])

loss = cross_entropy_loss(y_true, y_pred)
print(loss)

输出：

0.34657359027997264

6. 用 NumPy 实现简单的神经网络

这里是一个单层的（没有反向传播，只有前向传播）

# 初始化参数
np.random.seed(42)
W = np.random.rand(2, 3)  # 权重矩阵
b = np.random.rand(2)     # 偏置向量

# 输入数据
x = np.array([1, 2, 3])

# 前向传播
z = np.dot(W, x) + b
a = sigmoid(z)

print("输出:", a)

输出: [0.99999976 0.99999982]

--------------------分割线---------------
补充一些东西
 

7.广播机制 

广播（broadcasting）机制，能让不同形状的数组在运算时自动扩展，使得操作变得更灵活
 

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([[10], [20], [30]])

result = arr1 + arr2
print(result)

#输出：
[[11 12 13]
 [21 22 23]
 [31 32 33]]

解释一下：arr1 是一维数组，arr2 是二维数组，但 NumPy 的广播机制让它们可以直接相加，而无需手动调整形状

8. 数据类型 (dtype) 和数组属性

在讲解数组创建的部分，补充一下关于 NumPy 数组数据类型（dtype）的内容

arr = np.array([1, 2, 3], dtype=np.float32)
print(arr.dtype)  # 输出: float32

8. 数组切片和索引操作

数组的切片和索引在深度学习中的数据处理非常常用，尤其在提取特定的行、列或者小块区域时

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 获取第二行
print(arr[1])

# 获取第一列
print(arr[:, 0])

# 获取子矩阵
print(arr[0:2, 1:3])

#输出
[4 5 6]
[1 4 7]
[[2 3]
 [5 6]]

9. 矩阵转置和求逆

转置（transpose()）和求逆（inv()）在深度学习中，比如在反向传播中的梯度计算，常常会用到

# 矩阵转置
A = np.array([[1, 2], [3, 4]])
A_T = np.transpose(A)
print(A_T)

# 矩阵求逆
from numpy.linalg import inv
A_inv = inv(A)
print(A_inv)

#输出
[[1 3]
 [2 4]]
[[-2.   1. ]
 [ 1.5 -0.5]]