当前位置：首页 > news >正文

python学习打卡day48

news 2025/8/30 17:00:27

知识点回顾：

随机张量的生成：torch.randn函数
卷积和池化的计算公式（可以不掌握，会自动计算的）
pytorch的广播机制：加法和乘法的广播机制

ps：numpy运算也有类似的广播机制，基本一致

import torch
# 生成标量（0维张量）
scalar = torch.randn(())
print(f"标量: {scalar}, 形状: {scalar.shape}")  # 标量: -1.6167410612106323, 形状: torch.Size([])# 生成向量（1维张量）
vector = torch.randn(5)  # 长度为5的向量
print(f"向量: {vector}, 形状: {vector.shape}")  # 向量: tensor([-1.9524,  0.5900,  0.7467, -1.8307,  0.4263]), 形状: torch.Size([5])# 生成矩阵（2维张量）
matrix = torch.randn(3, 4)  # 3行4列的矩阵
print(f"矩阵：{matrix},矩阵形状: {matrix.shape}")  # 矩阵：tensor([[ 0.0283,  0.7692,  0.2744, -1.6120],
#       [ 0.3726,  1.5382, -1.0128,  0.4129],
#       [ 0.4898,  1.4782,  0.2019,  0.0863]]),矩阵形状: torch.Size([3, 4])# 生成3维张量（常用于图像数据的通道、高度、宽度）
tensor_3d = torch.randn(3, 224, 224)  # 3通道，高224，宽224
print(f"3维张量形状: {tensor_3d.shape}")  # 输出: torch.Size([3, 224, 224])# 3维张量形状: torch.Size([3, 224, 224])# 生成4维张量（常用于批量图像数据：[batch, channel, height, width]）
tensor_4d = torch.randn(2, 3, 224, 224)  # 批量大小为2，3通道，高224，宽224
print(f"4维张量形状: {tensor_4d.shape}")  # 输出: torch.Size([2, 3, 224, 224])# 4维张量形状: torch.Size([2, 3, 224, 224])、# torch.rand()：生成在 [0, 1) 范围内均匀分布的随机数。x = torch.rand(3, 2)  # 生成3x2的张量
print(f"均匀分布随机数: {x}, 形状: {x.shape}")# 均匀分布随机数: tensor([[0.2089, 0.7786],
#       [0.1043, 0.1573],
#       [0.9637, 0.0397]]), 形状: torch.Size([3, 2])# torch.randint()：生成指定范围内的随机整数x = torch.randint(low=0, high=10, size=(3,))  # 生成3个0到9之间的整数
print(f"随机整数: {x}, 形状: {x.shape}")# 随机整数: tensor([3, 5, 7]), 形状: torch.Size([3])# torch.normal()：生成指定均值和标准差的正态分布随机数。mean = torch.tensor([0.0, 0.0])
std = torch.tensor([1.0, 2.0])
x = torch.normal(mean, std)  # 生成两个正态分布随机数
print(f"正态分布随机数: {x}, 形状: {x.shape}")# 正态分布随机数: tensor([ 0.1419, -1.5212]), 形状: torch.Size([2])# 一维张量与二维张量相加
a = torch.tensor([[1, 2, 3], [4, 5, 6]])  # 形状: (2, 3)
b = torch.tensor([10, 20, 30])             # 形状: (3,)# 广播后：b被扩展为[[10, 20, 30], [10, 20, 30]]
result = a + b  
result# tensor([[11, 22, 33],
#        [14, 25, 36]])import torch
import torch.nn as nn# 生成输入张量 (批量大小, 通道数, 高度, 宽度)
input_tensor = torch.randn(1, 3, 32, 32)  # 例如CIFAR-10图像
print(f"输入尺寸: {input_tensor.shape}")  # 输出: [1, 3, 32, 32]# 二维的卷积和池化计算公式是一致的# 1. 卷积层操作
conv1 = nn.Conv2d(in_channels=3,        # 输入通道数out_channels=16,      # 输出通道数（卷积核数量）kernel_size=3,        # 卷积核大小stride=1,             # 步长padding=1             # 填充
)
conv_output = conv1(input_tensor) # 由于 padding=1 且 stride=1，空间尺寸保持不变
print(f"卷积后尺寸: {conv_output.shape}")  # 输出: [1, 16, 32, 32]# 2. 池化层操作 (减小空间尺寸)
pool = nn.MaxPool2d(kernel_size=2, stride=2) # 创建一个最大池化层
pool_output = pool(conv_output)
print(f"池化后尺寸: {pool_output.shape}")  # 输出: [1, 16, 16, 16]# 3. 将多维张量展平为向量
flattened = pool_output.view(pool_output.size(0), -1)
print(f"展平后尺寸: {flattened.shape}")  # 输出: [1, 4096] (16*16*16=4096)# 4. 线性层操作
fc1 = nn.Linear(in_features=4096,     # 输入特征数out_features=128      # 输出特征数
)
fc_output = fc1(flattened)
print(f"线性层后尺寸: {fc_output.shape}")  # 输出: [1, 128]# 5. 再经过一个线性层（例如分类器）
fc2 = nn.Linear(128, 10)  # 假设是10分类问题
final_output = fc2(fc_output)
print(f"最终输出尺寸: {final_output.shape}")  # 输出: [1, 10]
print(final_output)# 最终输出尺寸: torch.Size([1, 10])
# tensor([[-0.3018, -0.4308,  0.3248,  0.2808,  0.5109, -0.0881, -0.0787, -0.0700,
#          -0.1004, -0.0580]], grad_fn=<AddmmBackward>)# 多分类问题通常使用Softmax，二分类问题用Sigmoid# 使用Softmax替代Sigmoid
softmax = nn.Softmax(dim=1)  # 在类别维度上进行Softmax
class_probs = softmax(final_output)
print(f"Softmax输出: {class_probs}")  # 总和为1的概率分布
print(f"Softmax输出总和: {class_probs.sum():.4f}")# Softmax输出: tensor([[0.0712, 0.0626, 0.1332, 0.1275, 0.1605, 0.0882, 0.0890, 0.0898, 0.0871,
#          0.0909]], grad_fn=<SoftmaxBackward>)
# Softmax输出总和: 1.0000

import torch# 创建原始张量
a = torch.tensor([[10], [20], [30]])  # 形状: (3, 1)
b = torch.tensor([1, 2, 3])          # 形状: (3,)result = a + b
# 广播过程
# 1. b补全维度: (3,) → (1, 3)
# 2. a扩展列: (3, 1) → (3, 3)
# 3. b扩展行: (1, 3) → (3, 3)
# 最终形状: (3, 3)print("原始张量a:")
print(a)print("\n原始张量b:")
print(b)print("\n广播后a的值扩展:")
print(torch.tensor([[10, 10, 10],[20, 20, 20],[30, 30, 30]]))  # 实际内存中未复制，仅逻辑上扩展print("\n广播后b的值扩展:")
print(torch.tensor([[1, 2, 3],[1, 2, 3],[1, 2, 3]]))  # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)'''
原始张量a:
tensor([[10],[20],[30]])
原始张量b:
tensor([1, 2, 3])
广播后a的值扩展:
tensor([[10, 10, 10],[20, 20, 20],[30, 30, 30]])
广播后b的值扩展:
tensor([[1, 2, 3],[1, 2, 3],[1, 2, 3]])
加法结果:
tensor([[11, 12, 13],[21, 22, 23],[31, 32, 33]])
'''# 创建原始张量
a = torch.tensor([[[1], [2]], [[3], [4]]])  # 形状: (2, 2, 1)
b = torch.tensor([[10, 20]])               # 形状: (1, 2)# 广播过程
# 1. b补全维度: (1, 2) → (1, 1, 2)
# 2. a扩展第三维: (2, 2, 1) → (2, 2, 2)
# 3. b扩展第一维: (1, 1, 2) → (2, 1, 2)
# 4. b扩展第二维: (2, 1, 2) → (2, 2, 2)
# 最终形状: (2, 2, 2)result = a + b
print("原始张量a:")
print(a)print("\n原始张量b:")
print(b)print("\n广播后a的值扩展:")
print(torch.tensor([[[1, 1],[2, 2]],[[3, 3],[4, 4]]]))  # 实际内存中未复制，仅逻辑上扩展print("\n广播后b的值扩展:")
print(torch.tensor([[[10, 20],[10, 20]],[[10, 20],[10, 20]]]))  # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)'''
原始张量a:
tensor([[[1],[2]],[[3],[4]]])
原始张量b:
tensor([[10, 20]])
广播后a的值扩展:
tensor([[[1, 1],[2, 2]],[[3, 3],[4, 4]]])
广播后b的值扩展:
tensor([[[10, 20],[10, 20]],[[10, 20],[10, 20]]])
加法结果:
...[12, 22]],[[13, 23],[14, 24]]])
'''# 创建原始张量
a = torch.tensor([[1, 2], [3, 4]])  # 形状: (2, 2)
b = 10                              # 标量，形状视为 ()# 广播过程
# 1. b补全维度: () → (1, 1)
# 2. b扩展第一维: (1, 1) → (2, 1)
# 3. b扩展第二维: (2, 1) → (2, 2)
# 最终形状: (2, 2)result = a + b
print("原始张量a:")
print(a)
# 输出:
# tensor([[1, 2],
#         [3, 4]])print("\n标量b:")
print(b)
# 输出: 10print("\n广播后b的值扩展:")
print(torch.tensor([[10, 10],[10, 10]]))  # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)
# 输出:
# tensor([[11, 12],
#         [13, 14]])'''
原始张量a:
tensor([[1, 2],[3, 4]])
标量b:
10
广播后b的值扩展:
tensor([[10, 10],[10, 10]])
加法结果:
tensor([[11, 12],[13, 14]])
'''# 创建原始张量
a = torch.tensor([[[1, 2], [3, 4]]])  # 形状: (1, 2, 2)
b = torch.tensor([[5, 6]])            # 形状: (1, 2)# 广播过程
# 1. b补全维度: (1, 2) → (1, 1, 2)
# 2. b扩展第二维: (1, 1, 2) → (1, 2, 2)
# 最终形状: (1, 2, 2)result = a + b
print("原始张量a:")
print(a)
# 输出:
# tensor([[[1, 2],
#          [3, 4]]])print("\n原始张量b:")
print(b)
# 输出:
# tensor([[5, 6]])print("\n广播后b的值扩展:")
print(torch.tensor([[[5, 6],[5, 6]]]))  # 实际内存中未复制，仅逻辑上扩展print("\n加法结果:")
print(result)
# 输出:
# tensor([[[6, 8],
#          [8, 10]]])'''
原始张量a:
tensor([[[1, 2],[3, 4]]])
原始张量b:
tensor([[5, 6]])
广播后b的值扩展:
tensor([[[5, 6],[5, 6]]])
加法结果:
tensor([[[ 6,  8],[ 8, 10]]])
'''

@浙大疏锦行

查看全文

http://www.xdnf.cn/news/1395577.html