暑期学习笔记

Appearance

数据操作 ​

N维数组样例 ​

  N维数组是机器学习和神经网络的主要数据结构。

N维数组N维数组

创建数组 ​

创建数组

访问元素 ​

访问元素

Code ​

导包 ​

导入torch而不是pytorch

python
import torch

张量 ​

张量表示一个数值组成的数组，这个数组可能有多个维度

python
x = torch.arange(12)
x
txt
    tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

查看形状/总数/维度/数据类型 ​

访问张量的 形状 、元素的 总数 、维度 和 数据类型

python
x.shape
txt
    torch.Size([12])
python
x.numel()
txt
    12
python
x.dim()
txt
    1
python
x.dtype
txt
    torch.int64

改变形状 ​

要改变张量的形状而不改变元素数量和元素值，用reshap函数

python
X = x.reshape(3, 4)
X
txt
    tensor([[ 0,  1,  2,  3],
            [ 4,  5,  6,  7],
            [ 8,  9, 10, 11]])

自定义值 ​

使用全0、全1、其他常量或者从特定分布中随机采样的数字，参数为 形状 (可以传多个值也可以直接传元组)

python
torch.zeros((2, 3, 4))
txt
    tensor([[[0., 0., 0., 0.],
             [0., 0., 0., 0.],
             [0., 0., 0., 0.]],
    
            [[0., 0., 0., 0.],
             [0., 0., 0., 0.],
             [0., 0., 0., 0.]]])
python
torch.ones((2, 3, 4))
txt
    tensor([[[1., 1., 1., 1.],
             [1., 1., 1., 1.],
             [1., 1., 1., 1.]],
    
            [[1., 1., 1., 1.],
             [1., 1., 1., 1.],
             [1., 1., 1., 1.]]])
python
torch.randn(3, 4)
txt
    tensor([[ 0.1162,  0.3479,  0.0283, -1.0206],
            [-0.3514, -0.9523, -0.9063, -0.3924],
            [-0.4195,  0.0421, -0.1658,  0.1655]])

通过包含数值的Python列表(或嵌套列表)来为所需张量中的每个元素赋予确定值

python
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
txt
    tensor([[2, 1, 4, 3],
            [1, 2, 3, 4],
            [4, 3, 2, 1]])

运算 ​

常见的标准算术运算符(+、-、*、/和**)都可以被升级为 按元素 运算

python
x = torch.tensor([1.0, 2, 4, 8]) # 使用 1.0 创建浮点型数组
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y
txt
    (tensor([ 3.,  4.,  6., 10.]),
     tensor([-1.,  0.,  2.,  6.]),
     tensor([ 2.,  4.,  8., 16.]),
     tensor([0.5000, 1.0000, 2.0000, 4.0000]),
     tensor([ 1.,  4., 16., 64.]))

按元素方式应用更多的计算

python
torch.exp(x)  # 逐元素计算自然指数(e的x次方)
txt
    tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
python
torch.log(x)  # 逐元素计算自然对数(exp的逆运算)
txt
    tensor([0.0000, 0.6931, 1.3863, 2.0794])
python
a = 2
torch.pow(a, x)  # 以a为底逐元素为指数
txt
    tensor([  2.,   4.,  16., 256.])

把多个张量连结(concatenate)在一起

python
# 指定数据类型为32位浮点数 dtype=torch.float32
X = torch.arange(12, dtype=torch.float32).reshape((3, 4)) 
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
# torch.cat((A,B), dim=n)：在第n个维度上拼接两个张量，其余维度尺寸必须完全相同
# dim=0:行维度(第0维,最外层)  dim=1:列维度(第1维,内层)
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
txt
    (tensor([[ 0.,  1.,  2.,  3.],
             [ 4.,  5.,  6.,  7.],
             [ 8.,  9., 10., 11.],
             [ 2.,  1.,  4.,  3.],
             [ 1.,  2.,  3.,  4.],
             [ 4.,  3.,  2.,  1.]]),
     tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
             [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
             [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

通过 逻辑运算符 构建二元张量

python
X == Y
txt
    tensor([[False,  True, False,  True],
            [False, False, False, False],
            [False, False, False, False]])

对张量中的所有元素进行求和会产生一个只有一个元素的张量

python
X.sum()
txt
    tensor(66.)

即使形状不同(维度相同)，仍然可以通过调用广播机制(broadcasting mechanism)来执行按元素操作

python
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
txt
    (tensor([[0],
             [1],
             [2]]),
     tensor([[0, 1]]))
python
a + b
txt
    tensor([[0, 1],
            [1, 2],
            [2, 3]])

元素的读写 ​

用-1选择最后一个元素，用[1:3]选择第二和第三个元素

python
X[-1], X[1:3]
txt
    (tensor([ 8.,  9., 10., 11.]),
     tensor([[ 4.,  5.,  6.,  7.],
             [ 8.,  9., 10., 11.]]))

通过指定索引来将元素写入矩阵

python
X[1, 2] = 9
X
txt
    tensor([[ 0.,  1.,  2.,  3.],
            [ 4.,  5.,  9.,  7.],
            [ 8.,  9., 10., 11.]])

为多个元素赋值相同的值，只需要索引所有元素，然后为它们赋值

python
X[0:2, :] = 12
X
txt
    tensor([[12., 12., 12., 12.],
            [12., 12., 12., 12.],
            [ 8.,  9., 10., 11.]])

关于内存 ​

运行一些操作可能会导致为新结果分配内存

python
before = id(Y)
Y = Y + X
id(Y) == before
txt
    False

执行原地操作

python
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
txt
    id(Z): 2427717363488
    id(Z): 2427717363488

如果在后续计算中没有重复使用X，也可以使用X[:] = X + Y或X += Y来减少操作的内存开销

与列表等可变容器逻辑一致
 list, bytearray, collections.deque, array.array, numpy.ndarray
X = X + Y：先执行 __add__，返回新对象，再赋值绑定变量；
X += Y：优先执行 __iadd__（原地加法），直接修改自身；
如果对象没有 __iadd__ 方法（如数字、字符串），才会退化成 X = X + Y。
 不支持的容器：set和dict
 不可变类型：int, float, str, bytes, tuple, frozenset

python
before = id(X)
X += Y    # 等价于 X[:] = X + Y
id(X) == before
txt
    True

转为 NumPy 张量 ​

python
A = X.numpy()
B = torch.tensor(A)
type(A), type(B)
txt
    (numpy.ndarray, torch.Tensor)

转为Python标量 ​

将大小为1的张量转换为Python标量

python
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)
txt
    (tensor([3.5000]), 3.5, 3.5, 3)

数据预处理 ​

创建一个人工数据集，并存储在csv(逗号分隔值)文件

python
import os

os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n')  # 列名
    f.write('NA,Pave,127500\n')  # 每行表示一个数据样本
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

从创建的csv文件中加载原始数据集

python
# 安装pandas
# !pip install pandas
import pandas as pd

data = pd.read_csv(data_file)
print(data)
txt
       NumRooms Alley   Price
    0       NaN  Pave  127500
    1       2.0   NaN  106000
    2       4.0   NaN  178100
    3       NaN   NaN  140000

为了处理缺失的数据，典型的方法包括 插值 和 删除，这里使用 插值

python
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
# inputs = inputs.fillna(inputs.mean()
# pandas >= 2.0.0，必须显式指定 numeric_only=True 才能跳过非数值列
# print(pd.__version__)
inputs = inputs.fillna(inputs.mean(numeric_only=True))
print(inputs)
txt
       NumRooms Alley
    0       3.0  Pave
    1       2.0   NaN
    2       4.0   NaN
    3       3.0   NaN

对于inputs中的类别值或离散值，可以将 NaN(Not a Number) 视为一个类别

python
# inputs = pd.get_dummies(inputs, dummy_na=True)
# pandas2.0.0+版本中get_dummies()默认生成布尔类型(True/False)而非整数(0/1)
# 显式设置 dtype=int
inputs = pd.get_dummies(inputs, dummy_na=True, dtype=int)
print(inputs)
txt
       NumRooms  Alley_Pave  Alley_nan
    0       3.0           1          0
    1       2.0           0          1
    2       4.0           0          1
    3       3.0           0          1

现在inputs和outputs中的所有条目都是数值类型，可以转换为张量格式

python
import torch

# 显式转为float32更安全，否则为float64
# X, y = torch.tensor(inputs.values, dtype=torch.float32), torch.tensor(outputs.values, dtype=torch.float32)
X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
X, y
txt
    (tensor([[3., 1., 0.],
             [2., 0., 1.],
             [4., 0., 1.],
             [3., 0., 1.]], dtype=torch.float64),
     tensor([127500, 106000, 178100, 140000]))

常见问题 ​

reshape 和 view 的区别 ​

view：
  要求输入的张量是内存连续的tensor.is_contiguous() == True
  始终与原张量共享内存(返回视图)，修改view的结果会同步影响原张量。
reshape：
  当张量连续时：共享内存(等价于view)。
  当张量不连续时：复制新内存(不共享)。

python
# 若张量在内存中连续
a = torch.arange(12)
b = a.reshape((3, 4))
b[:] = 2
a
txt
    tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
python
x = torch.randn(2, 3)
x_trans = x.transpose(0, 1)  # 非连续张量

# 检查连续性
print("转置后是否连续:", x_trans.is_contiguous())  # False

# 对比行为
try:
    x_trans.view(6)
except RuntimeError as e:
    print("view报错:", e)  # 触发错误

y_reshape = x_trans.reshape(6)
print("reshape成功:", y_reshape.shape)  # torch.Size()

# 内存地址验证（非连续时reshape会复制内存）
print("原张量内存地址:", x_trans.data_ptr())
print("reshape后地址:", y_reshape.data_ptr())  # 地址不同 → 已复制
txt
    转置后是否连续: False
    view报错: view size is not compatible with input tensor's size and stride (at least one dimension spans across two contiguous subspaces). Use .reshape(...) instead.
    reshape成功: torch.Size([6])
    原张量内存地址: 2427644307456
    reshape后地址: 2427644304704