本文深入介绍了PyTorch的基础知识，从Numpy的使用开始，包括数组生成、算术运算、数组变形、批量处理和广播机制。接着，详细阐述了PyTorch与Numpy的互换、自动梯度机制、使用Numpy和PyTorch实现机器学习的步骤。此外，还探讨了PyTorch的神经网络工具箱，包括构建网络、优化器和动态修改学习率的方法。最后，提到了PyTorch的数据处理工具箱，如DataLoader和数据集的使用，以及Tensorboard的可视化应用。通过本文，读者将全面了解PyTorch的基石和核心概念。
深度学习框架：TensorFlow、PyTorch、Keras、FastAI、CNTK等。
神经网络：卷积神经网络、循环神经网络、对抗式神经网络
目录
第一部分 PyTorch基础
1、Numpy基础
1.1 生成Numpy数组
import numpy as np
# 1、创建数组
lst1 = [3.14, 2.17, 0, 1, 2]
nd1 = np.array(lst1) # 列表转换成ndarray
print(nd1) # [3.14 2.17 0. 1. 2. ]
print(type(nd1)) # <class 'numpy.ndarray'>
lst2 = [[3.14, 2.17, 0, 1, 2], [1, 2, 3, 4, 5]]
nd2 = np.array(lst2) # 嵌套列表可以转换成多维ndarray
print(nd2)
# [[3.14 2.17 0. 1. 2. ]
# [1. 2. 3. 4. 5. ]]
# 2、随机生成数组
np.random.seed(123) # 指定一个随机种子，每次生成同一份数据
nd3 = np.random.random([3, 3]) # 生成0-1之间的随机数
print(nd3)
# [[0.69646919 0.28613933 0.22685145]
# [0.55131477 0.71946897 0.42310646]
# [0.9807642 0.68482974 0.4809319 ]]
np.random.shuffle(nd3) # 打乱生成的随机数
print(nd3)
# [[0.9807642 0.68482974 0.4809319 ]
# [0.69646919 0.28613933 0.22685145]
# [0.55131477 0.71946897 0.42310646]]
print("nd3的形状为:", nd3.shape) # nd3的形状为: (3, 3)
# 3、创建特定形状的多维数组
nd5 = np.zeros([3, 3]) # 生成全是 0 的 3x3 矩阵
# np.zeros_like(nd5) # 生成与nd5形状一样的全0矩阵
nd6 = np.ones([3, 3]) # 生成全是 1 的 3x3 矩阵
nd7 = np.eye(3) # 生成 3 阶的单位矩阵
nd8 = np.diag([1, 2, 3]) # 生成 3 阶对角矩阵
print(nd5)
# [[0. 0. 0.]
# [0. 0. 0.]
# [0. 0. 0.]]
nd9 = np.random.random([5, 5])
np.savetxt(X=nd9, fname='./test1.txt') # 保存数据到文件中
nd10 = np.loadtxt('./test1.txt')
print(nd10)
# 4、利用arange、linspace函数生成数组
# arange([start,] stop[,step,], dtype=None)
# start与stop用来指定范围，step用来设定步长。start默认为0，步长step可为小数
print(np.arange(10)) # [0 1 2 3 4 5 6 7 8 9]
print(np.arange(0, 10)) # [0 1 2 3 4 5 6 7 8 9]
print(np.arange(1, 4, 0.5)) # [1. 1.5 2. 2.5 3. 3.5]
print(np.arange(9, -1, -1)) # [9 8 7 6 5 4 3 2 1 0]1.2 获取元素
np.random.seed(2019)
nd11 = np.random.random([10]) # 生成0-1之间的随机数
print(nd11)
print(nd11[3]) # 获取指定位置的数据，获取第4个元素
print(nd11[3:6]) # 截取一段数据:包括3不包括6（从0开始）
print(nd11[1:6:2]) # 截取固定间隔数据
print(nd11[::-2]) # 倒序隔两位取数
nd12 = np.arange(25).reshape([5, 5]) # (0-24)截取一个多维数组的一个区域内数据
print(nd12)
print(nd12[1:3, 1:3]) # 2*2，不包括3
print(nd12[(nd12 > 3) & (nd12 < 10)]) # 截取一个多维数组中，数值在一个值域之内的数据
# 截取多维数组中，指定的行,如读取第2,3行
print(nd12[[1, 2]]) # 或nd12[1:3,:]
print(nd12[:, 1:3]) # 截取多维数组中，指定的列,如读取第2,3列
random.choice函数从指定的样本中随机抽取数据：
"""random.choice函数从指定的样本中随机抽取数据。"""
a = np.arange(1, 25, dtype=float)
print(a)
c1 = nr.choice(a, size=(3, 4)) # size指定输出数组形状
c2 = nr.choice(a, size=(3, 4), replace=False) # replace缺省为True，即可重复抽取。
# #下式中参数p指定每个元素对应的抽取概率，缺省为每个元素被抽取的概率相同。
c3 = nr.choice(a, size=(3, 4), p=a / np.sum(a))
print("随机可重复抽取")
print(c1)
print("随机但不重复抽取")
print(c2)
print("随机但按制度概率抽取")
print(c3)
1.3 Numpy的算术运算
对应元素相乘（Element-Wise Product）是两个矩阵中对应元素乘积。 np.multiply函数用于数组或矩阵对应元素相乘，输出与相乘数组或矩阵的大小一致。
A = np.array([[1, 2], [-1, 4]])
B = np.array([[2, 0], [3, 4]])
print(A * B) # 结果：[[2, 0], [-3, 16]]
print(np.multiply(A, B)) # 结果：[[2, 0], [-3, 16]]
数组通过一些激活函数后，输出与输入形状一致
X = np.random.rand(2, 3)
def softmoid(x):
return 1 / (1 + np.exp(-x))
def relu(x):
return np.maximum(0, x)
def softmax(x):
return np.exp(x) / np.sum(np.exp(x)) # (2, 3)
print("输入参数X的形状：", X.shape) # (2, 3)
print("激活函数softmoid输出形状：", softmoid(X).shape) # (2, 3)
print("激活函数relu输出形状：", relu(X).shape) # (2, 3)
print("激活函数softmax输出形状：", softmax(X).shape) # (2, 3)
点积运算（
Dot Product
）又称为内积，在
Numpy
用np.dot
表示。
"""矩阵乘法"""
X1 = np.array([[1, 2], [3, 4]])
X2 = np.array([[5, 6, 7], [8, 9, 10]])
X3 = np.dot(X1, X2)
print(X3)1.4 数组变形
更改数组的形状
"""1、reshape：改变向量的维度（不修改向量本身），所指定的行数或列数一定要能被整除"""
arr = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(arr) # 将向量 arr 维度变换为2行5列
print(arr.reshape(2, 5))
# 指定维度时可以只指定行数或列数, 其他用 -1 代替
print(arr.reshape(5, -1)) # 5行
print(arr.reshape(-1, 5)) # 5列
"""2、resize：改变向量的维度（修改向量本身）"""
# 将向量 arr 维度变换为2行5列
arr.resize(2, 5)
print(arr)
"""3、T：向量转置"""
arr = np.arange(12).reshape(3, 4) # 向量 arr 为3行4列
print(arr)
print(arr.T) # 将向量 arr 进行转置为4行3列
"""4、ravel：向量展平"""
arr = np.arange(6).reshape(2, -1) # 输出结果： [[0 1 2] [3 4 5]]
print(arr)
print(arr.ravel()) # 按照行优先，展平 [0 1 2 3 4 5]
print(arr.ravel('F')) # 按照列优先，展平 [0 3 1 4 2 5]
"""
5、flatten：把矩阵转换为向量
[[6. 7. 1. 2.]
[9. 5. 7. 2.]
[6. 4. 7. 2.]]
结果：
[6. 7. 1. 2. 9. 5. 7. 2. 6. 4. 7. 2.]
"""
a = np.floor(10 * np.random.random((3, 4)))
print(a)
print(a.flatten())
"""
6、squeeze：降维，把矩阵中含1的维度去掉。
[[0]
[1]
[2]]
结果：
[0 1 2]
[[[[0]
[1]]]
[[[2]
[3]]]
[[[4]
[5]]]]
结果：
[[0 1]
[2 3]
[4 5]]
"""
arr = np.arange(3).reshape(3, 1)
print(arr)
print(arr.shape) # (3,1)
print(arr.squeeze())
print(arr.squeeze().shape) # (3,)
arr1 = np.arange(6).reshape(3, 1, 2, 1)
print(arr1)
print(arr1.shape) # (3, 1, 2, 1)
print(arr1.squeeze().shape) # (3, 2)
print(arr1.squeeze())
"""
7、transpose：对高维矩阵进行轴对换，，比如把图片中表 示颜色顺序的RGB改为GBR
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
(2, 3, 4)
轴对换后：
[[[ 0 12]
[ 1 13]
[ 2 14]
[ 3 15]]
[[ 4 16]
[ 5 17]
[ 6 18]
[ 7 19]]
[[ 8 20]
[ 9 21]
[10 22]
[11 23]]]
(3, 4, 2)
"""
arr2 = np.arange(24).reshape(2, 3, 4)
print(arr2)
print(arr2.shape) # (2, 3, 4)
print(arr2.transpose(1, 2, 0))
print(arr2.transpose(1, 2, 0).shape) # (3, 4, 2)合并数组
"""1、append"""
# 一维数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.append(a, b)
print(c) # [1 2 3 4 5 6]
# 多维数组
a = np.arange(4).reshape(2, 2)
b = np.arange(4).reshape(2, 2)
c = np.append(a, b, axis=0) # 按行合并
print('按行合并后的结果:\n', c)
print('合并后数据维度:', c.shape)
d = np.append(a, b, axis=1) # 按列合并
print('按列合并后的结果\n', d)
print('合并后数据维度:', d.shape)
"""2、concatenate：沿指定轴连接数组或矩阵"""
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
c = np.concatenate((a, b), axis=0)
print(c)
d = np.concatenate((a, b.T), axis=1)
print(d)
"""3、stack：沿指定轴堆叠数组或矩阵"""
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(np.stack((a, b), axis=0))
1.5 批量处理
# 生成10000个形状为2X3的矩阵
data_train = np.random.randn(10000, 2, 3) # 标准正态的随机数
# 这是一个3维矩阵，第1个维度为样本数，后两个是数据形状
print(data_train.shape) # (10000,2,3)
np.random.shuffle(data_train) # 打乱这10000条数据
batch_size = 100 # 定义批量大小
# 进行批处理
for i in range(0, len(data_train), batch_size):
x_batch_sum = np.sum(data_train[i:i + batch_size])
print("第{}批次,该批次的数据之和:{}".format(i, x_batch_sum))
1.6 通用函数
math与numpy函数的性能比较
"""math与numpy函数的性能比较"""
x = [i * 0.001 for i in np.arange(1000000)]
start = time.clock()
for i, t in enumerate(x):
x[i] = math.sin(t)
print("math.sin:", time.clock() - start)
x = [i * 0.001 for i in np.arange(1000000)]
x = np.array(x)
start = time.clock()
np.sin(x)
print("numpy.sin:", time.clock() - start)
结论：numpy.sin比math.sin快近10倍
循环与向量运算比较
x1 = np.random.rand(1000000)
x2 = np.random.rand(1000000)
# 使用循环计算向量点积
tic = time.process_time()
dot = 0
for i in range(len(x1)):
dot += x1[i] * x2[i]
toc = time.process_time()
print("dot = " + str(dot) + "\n for loop----- Computation time = " + str(1000 * (toc - tic)) + "ms")
# 使用numpy函数求点积
tic = time.process_time()
dot = 0
dot = np.dot(x1, x2)
toc = time.process_time()
print("dot = " + str(dot) + "\n verctor version---- Computation time = " + str(1000 * (toc - tic)) + "ms")
1.7 广播机制
四条规则：
- 让所有输入数组都向其中shape最长的数组看齐，不足的部分则通过 在前面加1补齐，如： a：2×3×2 ；b：3×2 ；则b向a看齐，在b的前面加1，变为：1×3×2。
- 输出数组的shape是输入数组shape的各个轴上的最大值；
- 如果输入数组的某个轴和输出数组的对应轴的长度相同或者某个轴 的长度为1时，这个数组能被用来计算，否则出错；
- 当输入数组的某个轴的长度为1时，沿着此轴运算时都用（或复制） 此轴上的第一组值。
A = np.arange(0, 40, 10).reshape(4, 1) # 0 10 20 30 (4*1)
B = np.arange(0, 3) # [0 1 2] (3,)
print("A矩阵的形状:{},B矩阵的形状:{}".format(A.shape, B.shape))
C = A + B
print("C矩阵的形状:{}".format(C.shape))
print(C)2、PyTorch基础
GPU版本PyTorch：Python、PyTorch、GPU的驱动（英伟达的NVIDIA）、CUDA、cuDNN计算 框架
后台启动jupyter notebook：nohup jupyter notebook >/dev/null 2>&1 &（localhost:8888）
2.4 Numpy与Tensor
x = torch.tensor([1, 2])
y = torch.tensor([3, 4])
z = x.add(y) # x不变 z:tensor([4, 6]) x:tensor([1, 2])
x.add_(y) # x改变
torch.Tensor([1, 2, 3, 4, 5, 6]) # 根据list数据生成Tensor
torch.Tensor(2, 3) # 根据指定形状生成Tensor
t = torch.Tensor([[1, 2, 3], [4, 5, 6]]) # 根据给定的Tensor的形状生成Tensor
# 查看Tensor的形状
print(t.size()) # shape与size()等价方式：t.shape
torch.Tensor(t.size()) # 根据已有形状创建Tensor
"""torch.Tensor与torch.tensor的区别"""
t1 = torch.Tensor(1) # 默认dtype（FloatTensor）,返回一个大小为1的张量
t2 = torch.tensor(1) # 从数据中推断数据类型, 返回一个固定值1
print("t1的值{},t1的数据类型{}".format(t1, t1.type()))
print("t2的值{},t2的数据类型{}".format(t2, t2.type()))
"""自动生成Tensor"""
print(torch.eye(2, 2)) # 生成一个单位矩阵
print(torch.zeros(2, 3)) # 自动生成全是0的矩阵
print(torch.linspace(1, 10, 4)) # 根据规则生成数据
print(torch.rand(2, 3)) # 生成满足均匀分布随机数
print(torch.randn(2, 3)) # 生成满足标准分布随机数
print(torch.zeros_like(torch.rand(2, 3))) # 返回所给数据形状相同，值全为0的张量
"""修改Tensor形状"""
x = torch.randn(2, 3) # 生成一个形状为2x3的矩阵
print(x.size()) # 查看矩阵的形状, 结果为torch.Size([2, 3])
print(x.dim()) # 查看x的维度, 结果为2
x.view(3, 2) # 把x变为3x2的矩阵
y = x.view(-1) # 把x展平为1维向量
print(y.shape) # torch.Size([6])
z = torch.unsqueeze(y, 0) # 添加一个维度
print(z.size()) # 查看z的形状, 结果为torch.S
最低0.47元/天 解锁文章
扫一扫
1484
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
