一、数据操作
在colab上运行。
首先，导入torch。
import torch张量表示一个由数值组成的数组，这个数组可能有多个维度。
用 arange 创建一个行向量 x。这个行向量包含以0开始的前12个整数，它们默认创建为整数。
x = torch.arange(12)
x输出：tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
通过张量的shape属性来访问张量（沿每个轴的长度）的形状。
x.shape输出：torch.Size([12])
获取tensor中一共含有多少元素。
x.numel()输出：12
改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)。
X = x.reshape(4, 3)
X输出：
tensor([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
使用全0、全1、其他常量，或者从特定分布中随机采样的数字来初始化矩阵。下面例子为创建（2，3，4）的张量，所有元素设为0。若要将所有元素设为1，则为torch.ones((2,3,4))。
torch.zeros((2, 3, 4))输出：
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.]]])
从某个特定的概率分布中随机采样来得到张量中每个元素的值。 每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。
torch.randn(3, 4)输出：
tensor([[ 0.3362, 1.0435, -0.2366, -1.1356],
[ 1.0812, -0.6434, -0.0260, -0.0460],
[-2.1388, 0.5161, 0.1829, -1.1495]])
通过提供包含数值的Python列表（或嵌套列表），来为所需张量中的每个元素赋予确定值。 最外层的列表对应于轴0，内层的列表对应于轴1。
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])输出：
tensor([[2, 1, 4, 3],
[1, 2, 3, 4],
[4, 3, 2, 1]])
对于任意具有相同形状的张量， [常见的标准算术运算符（+、-、*、/和``）都可以被升级为按元素运算**]。 我们可以在同一形状的任意两个张量上调用按元素操作。1.0表示浮点数，则结果都将以浮点数形式输出。
x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # **运算符是求幂运算输出：
(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.]))
求幂。e的x次方。
torch.exp(x)输出：tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
把多个张量连结（concatenate）在一起， 把它们端对端地叠起来形成一个更大的张量。dim=0就是高维度（行），=1就是次高维度（列）。cat()拼接多个tensor。
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((X, Y), dim=0), torch.cat((X, Y), dim=1)输出：
(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.]]))
通过逻辑运算符构建二元张量。真为1，假为0。
X == Y输出：
tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
对张量中的所有元素进行求和。
X.sum()输出：tensor(66.)
广播机制：
通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
对生成的数组执行按元素操作。
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b输出：
(tensor([[0],
[1],
[2]]),
tensor([[0, 1]]))
a和b无法直接进行相加，故将两个矩阵广播为更大的矩阵，而后按元素相加。
a + b输出：
tensor([[0, 1],
[1, 2],
[2, 3]])
索引和切片：第一个元素的索引是0，最后一个元素索引是-1。除读取外，还可以通过指定索引来将元素写入矩阵。如X[1, 2] = 9。若想为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值。如[0:2, :]访问第1行和第2行，左闭右开区间，右边的“:”代表沿轴1（列）的所有元素。
节省内存：python的id()函数与c语言中的指针类似，为我们提供内存中引用对象的地址。
before = id(Y)
Y = Y + X
id(Y) == before输出：False
上述操作有时不可取，故采取执行原地操作。
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))输出：
id(Z): 139931132035296
id(Z): 139931132035296
或者使用X[:] = X + Y或X += Y。
转换为NumPy张量（ndarray）：
A = X.numpy()
B = torch.tensor(A)
type(A), type(B)输出：(numpy.ndarray, torch.Tensor)
要将大小为1的张量转换为Python标量，需调用item函数或Python的内置函数。
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)输出：(tensor([3.5000]), 3.5, 3.5, 3)
练习：
运行本节中的代码。将本节中的条件语句X == Y更改为X < Y或X > Y，然后看看你可以得到什么样的张量。
X>Y时：
tensor([[False, False, False, False],
[ True, True, True, True],
[ True, True, True, True]])
X<Y时：
tensor([[ True, False, True, False],
[False, False, False, False],
[False, False, False, False]])
用其他形状（例如三维张量）替换广播机制中按元素操作的两个张量。结果是否与预期相同？
a = torch.arange(3).reshape((1, 3, 1))
b = torch.arange(4).reshape((2, 1, 2))
a, b输出：
(tensor([[[0],
[1],
[2]]]), tensor([[[0, 1]],
[[2, 3]]]))
print(a + b)
(a + b).size()输出：
tensor([[[0, 1],
[1, 2],
[2, 3]],
[[2, 3],
[3, 4],
[4, 5]]])
torch.Size([2, 3, 2])
二、数据预处理
创建人工数据集，并存储在csv文件中。csv全称“Comma-Separated Values”，每个域用逗号隔开。
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文件中加载原始数据集，导入pandas包并调用read_csv函数。
# !pip install pandas
import pandas as pd
data = pd.read_csv(data_file)
print(data)输出：
NumRooms Alley Price
0 NaN Pave 127500
1 2.0 NaN 106000
2 4.0 NaN 178100
3 NaN NaN 140000
“NaN”项代表缺失值。 为了处理缺失的数据，典型的方法包括插值法和删除法。iloc为位置索引，通过iloc，将data分为inputs与outputs，前者为data的前两列，而后者为data的最后一列。 对于inputs中缺少的数值，我们用同一列的均值替换“NaN”项。
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.mean(numeric_only=True))
print(inputs)输出：
NumRooms Alley
0 3.0 Pave
1 2.0 NaN
2 4.0 NaN
3 3.0 NaN
对于inputs中的类别值或离散值，我们将“NaN”视为一个类别。哪行有pave或nan中哪个项，哪一项值就为1，另一项为0。
inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)输出：
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中的所有条目都是数值类型，它们可以转换为张量格式。
import torch
X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
X, y输出：
(tensor([[3., 1., 0.],
[2., 0., 1.],
[4., 0., 1.],
[3., 0., 1.]], dtype=torch.float64),
tensor([127500, 106000, 178100, 140000]))
练习：
删除缺失值最多的列，并将预处理后的数据集转换为张量格式。
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')
f.write('3,Pave,170000\n')data1 = pd.read_csv(data_file)
data1
nan_num = data1.isnull().sum(axis=0)
nan_max = nan_num.idxmax()
data2 = data1.drop(nan_max,axis=1)
print(data2)
print(data1)输出：
NumRooms Price
0 NaN 127500
1 2.0 106000
2 4.0 178100
3 NaN 140000
4 3.0 170000
NumRooms Alley Price
0 NaN Pave 127500
1 2.0 NaN 106000
2 4.0 NaN 178100
3 NaN NaN 140000
4 3.0 Pave 170000
inputs=data2.iloc[:,:-1]
outputs=data2.iloc[:,-1]
X,y=torch.tensor(inputs.values),torch.tensor(outputs.values)
X,y输出：
(tensor([[nan],
[2.],
[4.],
[nan],
[3.]], dtype=torch.float64),
tensor([127500, 106000, 178100, 140000, 170000]))
91
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
