深度学习之Pytorch基础教程！

import torch

# 创建未初始化的Tensorx = torch.empty(5,3)print(x)

# 创建随机初始化的Tensorx = torch.rand(5,3)print(x)

    
# 创建全为0的Tensorx = torch.zeros(5,3,dtype=torch.long)print(x)

# 根据数据创建Tensorx = torch.tensor([5.5,3])print(x)

# 修改原Tensor为全1的Tensorx = x.new_ones(5,3,dtype=torch.float64)print(x)
# 修改数据类型x = torch.rand_like(x,dtype=torch.float64)print(x)

# 获取Tensor的形状print(x.size())print(x.shape)# 注意：返回的torch.Size其实就是⼀一个tuple, ⽀支持所有tuple的操作。

# 形式1：y = torch.rand(5,3)print(x+y)

# 形式2print(torch.add(x,y))# 还可以指定输出result = torch.empty(5, 3)torch.add(x, y, out=result)print(result)

# 形式3y.add_(x)print(y)

y = x[0,:]y += 1print(y)print(x[0,:])  # 观察x是否改变了

y = x.view(15)z = x.view(-1,5) #  -1所指的维度可以根据其他维度的值推出来print(x.size(),y.size(),z.size())

x += 1print(x)print(y)

x_cp = x.clone().view(15)x -= 1print(x)print(x_cp)

number：x = torch.randn(1)print(x)print(x.item())

x = torch.arange(1,3).view(1,2)print(x)y = torch.arange(1,4).view(3,1)print(y)print(x+y)

a = torch.ones(5)b = a.numpy()print(a,b)

a += 1print(a,b)

b += 1print(a,b)

import numpy as npa = np.ones(5)b = torch.from_numpy(a)print(a,b)

a += 1print(a,b)b += 1print(a,b)

# let us run this cell only if CUDA is available# We will use ``torch.device`` objects to move tensors in and out of GPUif torch.cuda.is_available():    device = torch.device("cuda")          # a CUDA device object    y = torch.ones_like(x, device=device)  # directly create a tensor on GPU    x = x.to(device)                       # or just use strings ``.to("cuda")``    z = x + y    print(z)    print(z.to("cpu", torch.double))       # ``.to`` can also change dtype together!

# 加入requires_grad=True参数可追踪函数求导x = torch.ones(2,2,requires_grad=True)print(x)print(x.grad_fn)

# 进行运算y = x + 2print(y)print(y.grad_fn)  # 创建了一个加法操作

print(x.is_leaf,y.is_leaf)

# 整点复杂的操作z = y * y * 3out = z.mean()print(z,out)

a = torch.randn(2,2)    # 缺失情况下默认 requires_grad = Falsea = ((a*3)/(a-1))print(a.requires_grad)  # Falsea.requires_grad_(True)print(a.requires_grad)b = (a*a).sum()print(b.grad_fn)

out.backward()print(x.grad)

# 再来反向传播⼀次，注意grad是累加的out2 = x.sum()out2.backward()print(x.grad)
out3 = x.sum()x.grad.data.zero_()out3.backward()print(x.grad)

import torchimport torch.nn as nnimport torch.nn.functional as F
class Net(nn.Module):
    def __init__(self):        super(Net,self).__init__()        # 1 input image channel, 6 output channels, 3x3 square convolution        # kernel        self.conv1 = nn.Conv2d(1,6,3)        self.conv2 = nn.Conv2d(6,16,3)        # an affine operation: y = Wx + b        self.fc1 = nn.Linear(16*6*6,120)   # 6*6 from image dimension        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))  # CLASStorch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)        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        print(num_features)        return num_features
net = Net()print(net)

# 模型的可学习参数由返回 net.parameters()params = list(net.parameters())print(len(params))print(params[0].size())  # conv1's .weight

# 尝试一个32x32随机输入input = torch.randn(1,1,32,32)out = net(input)print(out)

# 用随机梯度将所有参数和反向传播器的梯度缓冲区归零：net.zero_grad()out.backward(torch.randn(1,10))

output = net(input)target = torch.randn(10)    # a dummy target, for exampletarget = target.view(-1,1)  # # make it the same shape as outputcriterion = nn.MSELoss()
loss = criterion(output,target)print(loss)

# 如果loss使用.grad_fn属性的属性向后移动，可查看网络结构print(loss.grad_fn)  # MSELossprint(loss.grad_fn.next_functions[0][0])  # Linearprint(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

import torch.optim as optim
#  create your optimizeroptimizer = optim.SGD(net.parameters(),lr = 0.01)
# in your training loop:optimizer.zero_grad()  # zero the gradient buffersoutput = net(input)loss = criterion(output,target)loss.backward()optimizer.step()