构造不做初始化的矩阵： x = torch.empty(shape，dtype)
构造随机初始化的矩阵： x = torch.rand(shape)，返回 [0,1)之间的均匀 分布的一组张量,不需要指定类型
x = torch.randn(shape),返回一组满足标准正态分布的张量
构造一个矩阵全为 0，数据类型是 long: x = torch.zeros(5, 3, dtype=torch.long)
构造一个矩阵全为 1：x = torch.zeros(shape，dtype)
构造普通张量：x = torch.tensor([5.5, 3])
基于已经存在的 tensor构造新的tensor :
y = x.new_ones(shape) 这是构造一个全为1，且shape的矩阵，如不指定dtype或者其他属性，则继承x的属性
z = torch.randn_like(x, dtype) 构造形状与x相同的矩阵
获取一个张量的维度信息：x.shape 或者 x.size( )
基础运算：
加： 使用‘ + ’
torch.add( x, y,out = result ), 这种方法可以将结果保存在out中
x.add_( y ),这种带‘_’的方法，会直接改变x的值，将x+y的结果赋值给x
索引操作和numpy的操作类似
改变大小：如果你想改变一个 tensor 的大小或者形状，你可以使用 torch.view:
只有一个元素 tensor ，使用 .item() 来获得这个 value 。
PyTorch 自动微分
如果将其属性 .requires_grad 设置为 True，则会开始跟踪针对 tensor 的所有操作。完成计算后，您可以调用 .backward( ) 来自动计算所有梯度。该张量的梯度将累积到 .grad 属性中。
每个张量都有一个 .grad_fn 属性保存着创 建了张量的 Function 的引用，（如果用户自己创建张量，则grad_fn 是 None ）。
.requires_grad_( ) 会改变张量的 requires_grad 标记。输入的标记默认为 False ，如果没有提供相应的参数。
x = torch.ones(2, 2, requires_grad=True)
输出x : tensor([[1., 1.],
[1., 1.]], requires_grad=True)
y = x + 2
输出y : tensor([[3., 3.],
[3., 3.]], grad_fn=)
z = y * y * 3
输出z：tensor([[27., 27.],
[27., 27.]], grad_fn=)
out = z.mean()
输出out : tensor(27., grad_fn=)
调用 Tensor.backward( )计算导数，如果 Tensor 是标量（即它包含一个元素数 据），则不需要指定任何参数backward()，但是如果它有更多元素，则需要指定一个gradient 参数 来指定张量的形状。
x = torch.ones(2, 2, requires_grad=True)
y = x + 2
z = y * y * 3
v = torch.tensor([[1,1],
[2,1]], dtype=torch.float32) 数据类型设置成浮点
z.backward(v) v的形状和x的相同
print(x.grad)
可以通过将代码包裹在 with torch.no_grad( )，来停止对从跟踪历史中的 .requires_grad=True 的 张量自动求导。
print(x.requires_grad) 输出：True
print((x ** 2).requires_grad) 输出：True
with torch.no_grad():
print((x ** 2).requires_grad) 输出：False
PyTorch 神经网络
神经网络可以通过 torch.nn 包来构建。神经网络是基于自动梯度 (autograd)来定义一些模型。 一个 nn.Module 包括层和一个方法 forward(input) 它会返回输出(output)。
import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def init(self):
super(Net, self).init()
# 1 input image channel, 6 output channels, 5x5 square convolution
# kernel
self.conv1 = nn.Conv2d(1, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
# Max pooling over a (2, 2) window
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
# 重置形状，平铺
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:]
# all dimensions except the batch dimension
num_features = 1
for s in size:
num_features *= s
return num_features
net = Net()
print(net)
输出：
Net(
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
一个模型可训练的参数可以通过调用 net.parameters( ) 返回：
params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1’s .weight
把所有参数梯度缓存器置零，用随机的梯度来反向传播
net.zero_grad( )
out.backward(torch.randn(1, 10))
损失函数在nn包中
criterion = nn.MSELoss( ) 均方误差
torch.optim包实现了所有的优化方法
