【colab pytorch】张量操作

tensor=torch.randn(3,4,5)
print(tensor.size())
print(tensor.type())
print(tensor.dim())

# 在PyTorch 1.3之前，需要使用注释
# Tensor[N, C, H, W]
images = torch.randn(32, 3, 56, 56)
images.sum(dim=1)
images.select(dim=1, index=0)

# PyTorch 1.3之后
NCHW = [‘N’, ‘C’, ‘H’, ‘W’]
images = torch.randn(32, 3, 56, 56, names=NCHW)
images.sum(‘C‘).size()#按通道相加

#选择第0个通道
images.select(‘C‘,index=0).size()

# 也可以这么设置
tensor = torch.rand(3,4,1,2,names=(‘C‘, ‘N‘, ‘H‘, ‘W‘))
# 使用align_to可以对维度方便地排序
tensor = tensor.align_to(‘N‘, ‘C‘, ‘H‘, ‘W‘)

# 设置默认类型，pytorch中的FloatTensor远远快于DoubleTensor
torch.set_default_tensor_type(torch.FloatTensor)

# 类型转换
tensor = tensor.cuda()
tensor = tensor.cpu()
tensor = tensor.float()
tensor = tensor.long()

ndarray = tensor.cpu().numpy()
tensor = torch.from_numpy(ndarray).float()
tensor = torch.from_numpy(ndarray.copy()).float() # If ndarray has negative stride.

from PIL import Image
import numpy as np
image=r‘/content/drive/My Drive/colab notebooks/image/test.jpg‘
tensor=torch.from_numpy(np.asarray(Image.open(image))).permute(2,0,1).float()/255.0
tensor.size()

import torchvision
tensor=torchvision.transforms.functional.to_tensor(PIL.Image.open(path))
tensor.size()

img=Image.fromarray(torch.clamp(tensor*255,min=0,max=255).byte().permute(1,2,0).cpu().numpy())
print(type(img))

image = torchvision.transforms.functional.to_pil_image(tensor)

image = PIL.Image.fromarray(ndarray.astype(np.uint8))

ndarray = np.asarray(PIL.Image.open(path))

value = torch.rand(1)
print(value)
print(value.item())

# 在将卷积层输入全连接层的情况下通常需要对张量做形变处理，
# 相比torch.view，torch.reshape可以自动处理输入张量不连续的情况。
tensor = torch.rand(2,3,4)
shape = (6, 4)
tensor = torch.reshape(tensor, shape)

tensor = tensor[torch.randperm(tensor.size(0))]  # 打乱第一个维度

# pytorch不支持tensor[::-1]这样的负步长操作，水平翻转可以通过张量索引实现
# 假设张量的维度为[N, C, H, W].
tensor = tensor[:,:,:,torch.arange(tensor.size(3) - 1, -1, -1).long()]

# Operation                 |  New/Shared memory | Still in computation graph |
tensor.clone()            # |        New         |          Yes               |
tensor.detach()           # |      Shared        |          No                |
tensor.detach.clone()()   # |        New         |          No                |

‘‘‘
注意torch.cat和torch.stack的区别在于torch.cat沿着给定的维度拼接，
而torch.stack会新增一维。例如当参数是3个10x5的张量，torch.cat的结果是30x5的张量，
而torch.stack的结果是3x10x5的张量。
‘‘‘
tensor = torch.cat(list_of_tensors, dim=0)
tensor = torch.stack(list_of_tensors, dim=0)

t1=torch.randn(10,5)
t2=torch.randn(10,5)
t3=torch.randn(10,5)
s1=torch.cat([t1,t2,t3],dim=0)
s2=torch.stack([t1,t2,t3],dim=0)
print(s1.size())
print(s2.size())

tensor=torch.tensor([0,2,1,3])
N=tensor.size(0)
num_classes=4
one_hot=torch.zeros(N,num_classes).long()
one_hot.scatter_(dim=1, index=torch.unsqueeze(tensor, dim=1), src=torch.ones(N, num_classes).long())

torch.nonzero(tensor)               # index of non-zero elements
torch.nonzero(tensor==0)            # index of zero elements
torch.nonzero(tensor).size(0)       # number of non-zero elements
torch.nonzero(tensor == 0).size(0)  # number of zero elements

torch.allclose(tensor1, tensor2)  # float tensor
torch.equal(tensor1, tensor2)     # int tensor

# Expand tensor of shape 64*512 to shape 64*512*7*7.
tensor = torch.rand(64,512)
torch.reshape(tensor, (64, 512, 1, 1)).expand(64, 512, 7, 7).size()

# Matrix multiplcation: (m*n) * (n*p) * -> (m*p).
result = torch.mm(tensor1, tensor2)

# Batch matrix multiplication: (b*m*n) * (b*n*p) -> (b*m*p)
result = torch.bmm(tensor1, tensor2)

# Element-wise multiplication.
result = tensor1 * tensor2

dist = torch.sqrt(torch.sum((X1[:,None,:] - X2) ** 2, dim=2))