深度学习之张量（Tensor）的创建、常见属性及数据转换

news2024/11/15 10:00:16

基本概念

PyTorch会将数据封装成张量（Tensor）进行计算，所谓张量就是元素为相同类型的多维矩阵。

张量是一个多维数组，通俗来说可以看作是扩展了标量、向量、矩阵的更高维度的数组。张量的维度决定了它的形状（Shape）

标量是 0 维张量，向量是 1 维张量，矩阵是 2 维张量

PyTorch中有3种数据类型：浮点数、整数、布尔。其中，浮点数和整数又分为8位、16位、32位、64位，加起来共9种。

创建Tensor

创建tensor的函数中有两个有默认值的参数dtype和device, 分别代表数据类型和计算设备

根据指定的数据创建张量

import torch
import numpy as np
#tensor是小写

def test():
    #标量创建张量
    a=torch.tensor(2)
    print(a,a.shape)
    print("--------------")

    #numpy数组创建张量
    b=np.random.randn(0,1)
    b=torch.tensor(b)
    print(b,b.shape,b.device)
    print("--------------")

    #list创建张量
    c=[[1,2,3],[4,5,6]]
    c=torch.tensor(c)
    print(c,c.shape,c.dtype)
    print("--------------")

    pass


if __name__=="__main__":
    test()

根据形状创建张量，也可用来创建指定数据的张量。

import torch
#Tensor为大写

def task():

    a=torch.Tensor(3,3)
    print(a)
    print("---------------")


    b=torch.Tensor([[1,2,3],[4,5,6]])
    print(b,b.shape,b.dtype)
    print("---------------")

    c=torch.Tensor([10])
    print(c,c.shape,c.dtype)
    print("---------------")
    
    pass
    
if __name__=="__main__":
    task()

创建指定类型的张量

import torch

def task():

    a=torch.IntTensor(3,3)
    print(a)
    print("---------------")

    b=torch.FloatTensor(3,3)
    print(b,b.dtype)
    print("---------------")

    c=torch.DoubleTensor(3,3)
    print(c,c.dtype)
    print("---------------")

    d=torch.LongTensor(3,3)
    print(d,d.dtype)
    print("---------------")

    e=torch.ShortTensor(3,3)
    print(e,e.dtype)
    print("---------------")

    pass
    
if __name__=="__main__":
    task()

创建线性和随机张量

线性张量

import torch

def task():

    a=torch.arange(1,9,3)
    print(a)
    print("---------------")

    b=torch.linspace(5,20,4)
    print(b)
    print("---------------")

    c=torch.logspace(1,3,2,base=4)
    #在4的1次方到4的3次方生成间隔均匀的两个数
    print(c)
    print("---------------")

    pass
    
if __name__=="__main__":
    task()

随机张量

import torch


def task():
    #设置随机数种子
    torch.manual_seed(100)
    #获取随机数种子
    print(torch.initial_seed())
    print("---------------")
    #生成随机张量
    print(torch.rand(3,3))
    print("---------------")
    #生成随机张量:标准正态分布
    print(torch.randn(3,3))
    print("---------------")
    # 原生服从正态分布：均值为5， 方差为20，形状为3*3的正态分布
    print(torch.normal(mean=5,std=20,size=(3,3)))

    pass
    
if __name__=="__main__":
    task()

注：不设置随机种子时，每次打印的结果不一样。

创建 0、1、单位矩阵、指定值张量

创建全0张量

import torch
import numpy as np

def task():
    #创建全0张量
    a=torch.zeros(3,3)
    print(a,a.dtype)
    print("---------------")
    b=np.ones((3,3))
    print(b)
    print("---------------")
    c=torch.zeros_like(torch.tensor(b))
    print(c)
    pass
    
if __name__=="__main__":
    task()

创建全1张量

import torch
import numpy as np

def task():
    #创建全1张量
    a=torch.ones(3,3)
    print(a,a.dtype)
    print("---------------")
    b=np.zeros((3,3))
    print(b)
    print("---------------")
    c=torch.ones_like(torch.tensor(b))
    print(c)
    pass
    
if __name__=="__main__":
    task()

创建单位矩阵张量

import torch
import numpy as np

def task():
    a=torch.eye(3)
    print(a)
    pass
    
if __name__=="__main__":
    task()

创建指定值张量

import torch
import numpy as np

def task():
    a=torch.full((3,3),111)
    print(a,a.dtype)
    print("---------------")
    b=np.zeros((3,3))
    c=torch.full_like(torch.tensor(b),222)
    print(c)
    pass
    
if __name__=="__main__":
    task()

Tensor常见属性

获取属性

切换设备

import torch

def task():
#获取属性
    a=torch.tensor(3)
    print(a.dtype,a.device,a.shape)
     #运行结果：torch.int64 cpu torch.Size([]) 


#切换设备
    #把数据切换到GPU进行运算
    device="cuda" if torch.cuda.is_available() else "cpu"
    b=a.to(device)
    print(b.device)
     #运行结果：cuda:0
    
    #使用cuda进行转换
    c=a.cuda()
    print(c)
     #运行结果：tensor(3, device='cuda:0')

    #直接创建在GPU上
    d=torch.tensor((3),device='cuda')
    print(d.device)
     #运行结果：cuda:0
    pass
    
if __name__=="__main__":
    task()

类型转换

import torch

def task():
    a=torch.tensor(3)
    print(a.dtype)
    #torch.int64

    #用type进行类型转换
    b=a.type(torch.float32)
    print(b.dtype)
    # torch.float32

    #使用类型方法
    c=b.half()
    print(c.dtype)
    # torch.float16

    d=b.double()
    print(d.dtype)
    # torch.float64

    e=b.long()
    print(e.dtype)
    # torch.int64

    pass
    
if __name__=="__main__":
    task()

Tensor数据转换

张量、Numpy

Tensor 自称为神经网络界的Numpy，它与 Numpy 相似，二者可以共享内存，且之间的转换非常方便和高效。

不过它们也有不同之处，最大的区别就是 Numpy会把ndarray放在CPU中进行加速运算，而由Torch产生的Tensor会放在GPU中进行加速运算(如果当前环境有GPU)。

PyTorch 的Tensor是PyTorch 封装的一种数据结构，类似于Numpy的ndarray。

张量转Numpy

内存共享

#浅拷贝

import torch
def task():
    data_tensor=torch.tensor([[1,2,3],[4,5,6]])
    data_numpy=data_tensor.numpy()
    print(type(data_tensor),type(data_numpy))
    print("-----------")
    #输出结果：略

    data_numpy[0,1]=50
    print(data_tensor,data_numpy)
#     tensor([[ 1, 50,  3],
#         [ 4,  5,  6]]) [[ 1 50  3]
#  [ 4  5  6]]

    pass
    
if __name__=="__main__":
    task()

内存不共享

#深拷贝

import torch
def task():
    data_tensor=torch.tensor([[1,2,3],[4,5,6]])
    #使用copy避免内存共享
    data_numpy=data_tensor.numpy().copy()
    print(type(data_tensor),type(data_numpy))
    print("-----------")
    #输出结果：略

    data_numpy[0,1]=50
    print(data_tensor,data_numpy)
# tensor([[1, 2, 3],
#         [4, 5, 6]]) [[ 1 50  3]
#  [ 4  5  6]]
    data_tensor[0,0]=20
    print(data_tensor,data_numpy)
# tensor([[20,  2,  3],
#         [ 4,  5,  6]]) [[ 1 50  3]
#  [ 4  5  6]]
    pass
    
if __name__=="__main__":
    task()

Numpy转张量

内存共享

#浅拷贝

import torch
import numpy as np

def task():
    data_numpy=np.array([[1,2,3],[4,5,6]])
    data_tensor=torch.from_numpy(data_numpy)
    print(type(data_tensor),type(data_numpy))
    print("--------")
    #输出结果：略

    data_tensor[0,1]=20
    print(data_tensor,data_numpy)
# tensor([[ 1, 20,  3],
#         [ 4,  5,  6]], dtype=torch.int32) [[ 1 20  3]
#  [ 4  5  6]]
    pass


if __name__=="__main__":
    task()

内存不共享

#深拷贝

import torch
import numpy as np

def task():
    data_numpy=np.array([[1,2,3],[4,5,6]])
    data_tensor=torch.tensor(data_numpy)
    print(type(data_tensor),type(data_numpy))
    print("--------")
    #输出结果：略

    data_tensor[0,1]=20
    print(data_tensor,data_numpy)
# tensor([[ 1, 20,  3],
#         [ 4,  5,  6]], dtype=torch.int32) [[1 2 3]
#  [4 5 6]]   
    pass


if __name__=="__main__":
    task()

Tensor与图像

图片转Tensor

import torch
from PIL import Image
from torchvision import transforms

def test():
    img_=r"./QQ图片20211207153728.jpg"
    img=Image.open(img_)

    #图片转化为tensor
    transform=transforms.ToTensor()
    img_tensor=transform(img)
    print(img_tensor)

if __name__=="__main__":
    test()

Tensor转图片

import torch
from PIL import Image
from torchvision import transforms

def test():
    #随机一个数据表示生成的图片
    img_=torch.randn(2,128,222)
    #创建一个transforms
    transform=transforms.ToPILImage()
    #转换图片
    img=transform(img_)
    img.show()
    #保存图片
    img.save("./test.jpg")


if __name__=="__main__":
    test()

Pytorch图像处理

import torch
from PIL import Image
from torchvision import transforms

def test():

    # 指定读取的文件路径
    imgpath = r"./test.jpg"
    # 加载图片
    img = Image.open(imgpath)
    # 图像转为Tensor
    transform = transforms.ToTensor()
    img_tensor = transform(img)
    # 去掉透明度值
    print(img_tensor.shape)
    # 检查CUDA是否可用并将tensor移至CUDA
    if torch.cuda.is_available():
        img_tensor = img_tensor.cuda()
    print(img_tensor.device)
    # 修改每个像素值
    img_tensor += 0.2

    # 将tensor移回CPU并转换回PIL图像
    img_tensor = img_tensor.cpu()
    transform = transforms.ToPILImage()
    img = transform(img_tensor)
    # 保存图像
    img.save("./ok.png")
if __name__=="__main__":
    test()