> x = torch.DoubleTensor([1, 1, 1])
> print(type(x)) # was torch.DoubleTensor
"<class 'torch.Tensor'>"
> print(x.type()) # OK: 'torch.DoubleTensor'
'torch.DoubleTensor'
> print(isinstance(x, torch.DoubleTensor)) # OK: True
True

> x = torch.ones(1)
> x.requires_grad #默认是False
False
> y = torch.ones(1)
> z = x + y
> # 显然z的该属性也是False
> z.requires_grad
False
> # 所有变量都不需要grad, 所以会出错
> z.backward()
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
>
> # 可以将`requires_grad`作为一个参数, 构造tensor
> w = torch.ones(1, requires_grad=True)
> w.requires_grad
True
> total = w + z
> total.requires_grad
True
> # 现在可以backward了
> total.backward()
> w.grad
tensor([ 1.])
> # x,y,z都是不需要梯度的,他们的grad也没有计算
> z.grad == x.grad == y.grad == None
True

y = x.data # x需要进行autograd
# y和x是共享内存的,但是这里y已经不需要grad了, 
# 所以会导致本来需要计算梯度的x也没有梯度可以计算.从而x不会得到更新!

y = x.data # x需要进行autograd
# y和x是共享内存的,但是这里y已经不需要grad了, 
# 所以会导致本来需要计算梯度的x也没有梯度可以计算.从而x不会得到更新!

> x = torch.zeros(1, requires_grad=True)
> with torch.no_grad():
...   y = x * 2
> y.requires_grad
False
>
> is_train = False
> with torch.set_grad_enabled(is_train):
...   y = x * 2
> y.requires_grad
False
> torch.set_grad_enabled(True) # this can also be used as a function
> y = x * 2
> y.requires_grad
True
> torch.set_grad_enabled(False)
> y = x * 2
> y.requires_grad
False

> device = torch.device("cuda:1")
> x = torch.randn(3, 3, dtype=torch.float64, device=device)
tensor([[-0.6344, 0.8562, -1.2758],
    [ 0.8414, 1.7962, 1.0589],
    [-0.1369, -1.0462, -0.4373]], dtype=torch.float64, device='cuda:1')
> x.requires_grad # default is False
False
> x = torch.zeros(3, requires_grad=True)
> x.requires_grad
True

> device = torch.device("cuda:1")
> x = torch.randn(3, 3, dtype=torch.float64, device=device)
tensor([[-0.6344, 0.8562, -1.2758],
    [ 0.8414, 1.7962, 1.0589],
    [-0.1369, -1.0462, -0.4373]], dtype=torch.float64, device='cuda:1')
> x.requires_grad # default is False
False
> x = torch.zeros(3, requires_grad=True)
> x.requires_grad
True

# 从列表中, 创建tensor
> cuda = torch.device("cuda")
> torch.tensor([[1], [2], [3]], dtype=torch.half, device=cuda)
tensor([[ 1],
    [ 2],
    [ 3]], device='cuda:0')

> torch.tensor(1)        # 创建scalar
tensor(1)

 > x = torch.randn(3, dtype=torch.float64)
 > torch.zeros_like(x)
 tensor([ 0., 0., 0.], dtype=torch.float64)
 > torch.zeros_like(x, dtype=torch.int)
 tensor([ 0, 0, 0], dtype=torch.int32)

> x = torch.randn(3, dtype=torch.float64)
 > x.new_ones(2) # 属性一致
 tensor([ 1., 1.], dtype=torch.float64)
 > x.new_ones(4, dtype=torch.int)
 tensor([ 1, 1, 1, 1], dtype=torch.int32)

# at beginning of the script
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

...

# then whenever you get a new Tensor or Module
# this won't copy if they are already on the desired device
input = data.to(device)
model = MyModule(...).to(device)

model = MyRNN()
 if use_cuda:
   model = model.cuda()

 # train
 total_loss = 0
 for input, target in train_loader:
   input, target = Variable(input), Variable(target)
   hidden = Variable(torch.zeros(*h_shape)) # init hidden
   if use_cuda:
     input, target, hidden = input.cuda(), target.cuda(), hidden.cuda()
   ... # get loss and optimize
   total_loss += loss.data[0]

 # evaluate
 for input, target in test_loader:
   input = Variable(input, volatile=True)
   if use_cuda:
     ...
   ...

 # torch.device object used throughout this script
 device = torch.device("cuda" if use_cuda else "cpu")

 model = MyRNN().to(device)

 # train
 total_loss = 0
 for input, target in train_loader:
   input, target = input.to(device), target.to(device)
   hidden = input.new_zeros(*h_shape) # has the same device & dtype as `input`
   ... # get loss and optimize
   total_loss += loss.item()      # get Python number from 1-element Tensor

 # evaluate
 with torch.no_grad():          # operations inside don't track history
   for input, target in test_loader:
     ...