【PyTorch】第一部分 PyTorch基础 -《Python深度学习基于PyTorch》

最新推荐文章于 2024-03-24 17:31:24 发布

VIP文章 THDoO

最新推荐文章于 2024-03-24 17:31:24 发布

阅读量614

点赞数

本文链接：https://blog.csdn.net/THDoO/article/details/116309214

版权

深度学习框架：TensorFlow、PyTorch、Keras、FastAI、CNTK等。

神经网络：卷积神经网络、循环神经网络、对抗式神经网络

2.7 使用Tensor及Antograd实现机器学习

第一部分 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：沿指定轴连接数组或矩阵""

最低0.47元/天解锁文章

THDoO

关注

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
【PyTorch】第一部分 PyTorch基础 -《Python深度学习基于PyTorch》

《Python深度学习基于PyTorch》深度学习框架：TensorFlow、PyTorch、Keras、FastAI、CNTK等。神经网络：卷积神经网络、循环神经网络、对抗式神经网络
复制链接

扫一扫