---

定义Tensor

下面是一个常见的tensor，包含了里面的数值，属性，以及存储位置

tensor([[0.3565，0.1826，0.6719],
        [0.6695，0.5364，0.7057]]，dtype=torch.float32,device='cuda:0')

Tensor的属性

Tensor属性描述了它们的形状、数据类型和存储它们的设备（CPU 或 GPU）

import torch
tensor = torch.rand( 3,4)
print(f"shape of tensor: {tensor. shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor. device}")

Shape of tensor: torch.size([3，4])

Datatype of tensor: torch.float32

Device tensor is stored on: cpu

Tensor存储的数值

Tensor 可以用多种方法进行初始化。

直接传数据

Tensor可以直接从数据进行创建，数据类型会自动适应。

import torch
data =[[1,2],[3,4]]
x_data = torch.tensor(data)
print(x_data)

tensor([[1,2],
        [3，4]])

使用Numpy数据

可以通过Numpy矩阵中进行创建

import torch
import numpy as np
np_array = np. array ([[1,2],
                       [3,4]])
x_np = torch.from_numpy ( np_array)
print(x_np)

利用已有tensor

根据已有的数据形式（形状，数据类型），创建出新的tensor

data = [[1，2],[3，4]]
x_data = torch.tensor(data)
# 保持了x_data的数据属性与形状
x_ones = torch.ones_like(x_data)
print(f"ones Tensor: \n {x_ones} \n")
# 保持形状不变但改变数据属性的新张量
x_rand = torch.rand_like(x_data，dtype=torch.float)
print(f"Random Tensor: \n {x_rand} \n")

Tensor存储的位置

Tensor可以保存在GPU中，或者保存在CPU中，在二者中可以进行切换

1. 在GPU中进行运算（前向传播、反向传播）
2. 在CPU中进行数据读取（从内存读取数据）与写入（保存到硬盘中）

CPU->GPU 

import torch
shape = (2, 3, )
rand_tensor = torch.rand( shape)
print(rand_tensor)
if torch.cuda.is_available( ) :
    rand_tensor = rand_tensor.cuda()
print(rand_tensor)

输出：

tensor([[e.3565，0.1826，0.6719],
        [e.6695，0.5364，0.7057]])
tensor([[e.3565，0.1826，0.6719],
        [e.6695，0.5364，0.7057]],device= 'cuda:e ')

GPU->CPU

shape = (2, 3,)
rand_tensor = torch.rand( shape)
print(rand_tensor)
if torch.cuda.is_available( ):
    rand_tensor = rand_tensor.cuda()
print( rand_tensor)
cpu_tensor = rand _tensor.cpu()
print(cpu_tensor)

使用to()自动进行切换张量存储位置：

这个方法非常灵活，可以自动处理类型转换和设备迁移。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  
# 检查并设置设备
x_cpu = torch.tensor([[1., 2.], [3., 4.]])  
# 在CPU上的张量
x_gpu = x_cpu.to(device)  
# 移动到GPU

数据的运算

这些操作中的每一个都可以在GPU上运行（通常比在CPU上运行的速度更快）。

tensor = torch.tensor([[1,2]，
                       [ 3,4]])
#矩阵乘法
result_1 = tensor @ tensor
print( result_1)
print("矩阵乘法，result_1 = \n", result_1)
#矩阵对应位置的元素相乘
result_2 = tensor *tensor
print("元素乘法，result_2 = \n", result_2)
result_3 = tensor + tensor
print("元素加法，result_3 = \n" , result_3)
agg = tensor.sum( )
agg_item = agg.item()#使用item()获取里面的值
print("求和，agg_item = " , agg_item，type( agg_item) )

在PyTorch中，当你想要从一个标量张量（即形状为(1,)或者空的张量）中提取出Python的原生数值（例如整数、浮点数）时，可以使用.item()方法。这个方法会返回张量中的数据，将其转换为Python的基本数据类型。

import torch

# 一个包含单个浮点数的张量
tensor_with_one_value = torch.tensor([3.5])

# 使用.item()方法提取该值
value = tensor_with_one_value.item()

print(value)  # 输出: 3.5

Tensor的拼接

将两个或者多个tensor进行拼接（concat），使用 torch.cat对tensor沿着一个特定的维度进行拼接。

tensor_1 = torch.tensor([[1,2,3,4]])
tensor_2 = torch.tensor([[5,6,7,8]])
print(torch.cat([tensor_1,tensor_2],dim=0))
print(torch.cat([tensor_1,tensor_2],dim=1))

我们平时的张量有两个维度↓和→：

↓就是0维度，→就是1维度。 

tensor([[1，2，3，4]，
        [5，6，7，8]])
tensor([[1，2，3,4,5, 6，7，8]])

数据的转换

Numpy转Tensor

import torch
import numpy as np
n=np.ones ( 5)
t = torch.from_numpy(n)

# 
[1. 1.1.1. 1.]
tensor([1., 1., 1., 1., 1.],dtype=torch.float64)

Tensor转Numpy

t = torch. ones ( 5)
n= t.numpy ()

图片转Tensor

from PIL import Image
from torchvision import transforms
image_path = r'image.png'
image = Image.open(image_path)
transform = transforms.ToTensor()
tensor_image = transform( image)
print(type(tensor_image) )

# <class 'torch . Tensor' >

Tensor转图片

import torch
from torchvision import transforms
tensor_image = torch.randn( ( 3,224,224))
transformed_image = transforms.ToPILImage( )(tensor_image)
save_path = r "form_tensor .jpg'
#保存图像
transformed_image.save( save_path)

transforms模块是torchvision库中的一个重要组成部分，它提供了一系列预定义的图像转换方法，用于对图像数据进行各种预处理，如裁剪、缩放、旋转、归一化等，以便于输入深度学习模型进行训练或测试。

比如ToTensor：将PIL Image或numpy.ndarray转换为torch.FloatTensor，范围从[0, 255]变为[0.0, 1.0]。 

比如Normalize：对图像像素值进行归一化处理，常用于使数据分布更加一致，加速模型收敛。

transform = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])

PyTorch处理图片案例

模拟从硬盘读取一张图片，使用pytorch在显卡上进行运算，随后把运算结果保存到硬盘

import torch
from torchvision import transforms
from PIL import Image
image_path = r"image.png"
save_path = r"result.png"
#加载图片
image = Image.open( image_path)

transform = transforms. ToTensor()
#应用转换
tensor_image = transform( image)
print(tensor_image)
#检查CuDA是否可用并将tensor移至CUDA
if torch.cuda.is_available( ) :
    tensor_image = tensor_image.to( ' cuda ')
# 对每个元素加一
tensor_image += 0.1
# 将tensor移回CPU并转换回PIL图像
tensor_image = tensor_image.to( ' cpu ')
transformed_image = transforms.ToPILImage()(tensor_image)
#保存图像
transformed_image.save( save_path)