11.21 深度学习-tensor常见操作

import torch

from PIL import Image

from torchvision import transforms

#  获取元素值 tensor.item() 返回一个数值 只能是tensor里面有一个数字的

# 我们可以把单个元素tensor转换为Python数值，这是非常常用的操作

# tensor 里面超过了1个数字就不行

def get_item():

    t1=torch.tensor(1)

    t2=torch.tensor([[[100]]])

    x=t1.item()

    print(x)

    x=t2.item()

    print(x)

    pass

# 元素值四则运算

def compute():

    # 加减乘除

    torch.manual_seed(666)

    t1=torch.rand(3,3)

    # 末尾有下划线的直接是改变原来的数据

    # 对tensor里面的每个元素都 进行 四则运算操作

    # + add

    t1_add=t1.add(1)

    t1.add_(1)

    # - sub

    t1_sub=t1.sub(-1)

    t1.sub_(1)

    # * / 次方同理  mul div  pow

   

    # 也可以通过运算符号来进行 tensor类里面有魔术方法实现了 四则 次方 // % 都可以 这个没有对原来数据进行改变的

    t2=t1+10

    t3=t1**2

    print(t3)

    pass

def hadamard():

    # 两个tensor相同位置的元素相乘 两个tensor形状要一样

    # 阿达玛积指的是矩阵对应位置的元素相乘，可以使用mul函数或者*来实现 其实就是上面的乘法换成了 两个tensor 相乘

    data1 = torch.tensor([[1, 2, 3], [4, 5, 6]])

    data2 = torch.tensor([[2, 3, 4], [2, 2, 3]])

    print(data1 * data2)

    print(data1.mul(data2))

    pass

# 点积

def dotProduct():

    # 就是矩阵乘法的意思 第一个矩阵列数 和第二个矩阵的行数要相同 结果矩阵的形状为(第一个矩阵的行，第二个矩阵的列)

   

    data1 = torch.tensor([

        [1, 2, 3],  

        [4, 5, 6]

    ])

    data2 = torch.tensor([

        [3, 2],

        [2, 3],

        [5, 3]

    ])

    # 使用@或者matmul完成Tensor的乘法。  @ 是点积的符号 a@b  matmul和 mm是tensor的方法 mm只能用于二维的矩阵乘法 就是只有行列的 一般都是二维或者三维 乘法没有交换律注意顺序

    # mm方法也可以用于矩阵相乘 但是只能用于2维矩阵即:$$m*k$$和$$k*n$$ 得到$$m*n$$ 的矩阵

    res1=data1 @ data2

    res2=data1.matmul(data2)

    res3=data1.mm(data2)

    pass

# 索引操作

def index():

    torch.manual_seed(666)

    t1=torch.rand(3,5,5)

    # 跟np数组嵌套的索引差不多 就是嵌套列表的取法 套几个索引

    t1[1]

    t1[1,1]

    t1[1,1,1]

    # 取范围 第一维取 0 和1 取出来的矩阵在取 1

    t1[0:2,1]

    t1[0:2,1:3]

   

    t1[[1,2]] # 取第一维的1和3 在一个维度上取多个的时候传个矩阵进去 这个不会降维的 取出来就相当于重新组了一下 不是切片

    t1[[1,2],[1,1]] # 对应 矩阵取出来 [1,1] [2,1]

    # 也可以进行布尔运算 跟np差不多 返回的是一个布尔矩阵 布尔矩阵可以拿去 返回为ture的元素 返回出来变为1维的了

    x2=t1>0.5

    # print(x2)

    # print(t1[x2])

    # print(t1[t1>0.5])

    # 行级别的条件索引

    t2=torch.rand(5,5)

    x3=t2[:,1]>6 # 所有行的第一列大于6的 前面是行范围 后面是范围  对应一维范围 二维范围 三维范围。。。。 最后一维范围只能是一个数 对最后一维进行判断或者赋值

    t1[0:2,0:2,1]>0.5

    t2[x3]

    # 索引也可以拿来赋值 就是修改数据 取索引然后赋值

    t2[:,:]=6

    print(t2)

    pass

# 张量的拼接 torch的方法 返回一个新的tensor

# 在 PyTorch 中，cat 和 stack 是两个用于拼接张量的常用操作，但它们的使用方式和结果略有不同：

# - **cat**：在现有维度上拼接，不会增加新维度。

# - **stack**：在新维度上堆叠，会增加一个维度。

def splice():

    torch.manual_seed(666)

    t1=torch.rand(3,3)

    t2=torch.rand(3,3)

    # torch.cat（concatenate 的缩写）用于沿现有维度拼接张量。换句话说，它在现有的维度上将多个张量连接在一起。 就是np数组的拼接方式

    # torch.cat（） 传参 ：第一个 数组 里面是要拼接的tensor 第二个 dim 拼接的轴 注意 拼接的轴 另一个轴的数据量要一样 拼接的轴数据量可以不一样

    # 拼接 一个人完了再下一个人

    t3=torch.cat([t1,t2],dim=0)

    # print(t3)

    # 堆叠 交替添加

    # torch.stack 用于在新维度上拼接张量。换句话说，它会增加一个新的维度，然后沿指定维度堆叠张量 两个矩阵必须size一样

    t4=torch.stack([t1,t2],dim=2)

    print(t4.shape)

    # stack 补充解析

    # 1. 从维度的视角看 会新加一个维度 维度的大小为进行stack矩阵的数量 然后这个位置在新tensor的位置就是dim

    # 2. 从矩阵变换的视角看 比如二维矩阵  dim = 0 就是自己创建一个新的数组然后把 进行stack的两个矩阵放进去

    # dim=1 就是两个矩阵 轮流取第一层的元素组成一个新矩阵的第一层

    # dim=2 就是两个矩阵 轮流取第二层的元素组成新矩阵的第二层 新矩阵的第一层为

    pass

# stack应用 把Image的tensor 转为 cv2的tensor

def demo1():

    transform1=transforms.ToTensor()

    img1=Image.open("assets/image/1.png")

    # img1_t1=transform1(img1)

    img1_t1=torch.rand(4,5,6,7)

    print(img1_t1.shape)

    img1_t2=torch.stack([img1_t1[0],img1_t1[1],img1_t1[2],img1_t1[3]],dim=3)

    print(img1_t2.shape)

 

if __name__=="__main__":

    # get_item()

    # compute()

    # hadamard()

    # dotProduct()

    # index()

    # splice()

    # demo1()

    splice()

    pass

import torch

from PIL import Image

from torchvision import transforms

def sci():

    torch.set_printoptions(sci_mode=False)

    return 0

# 形状操作

# reshape torch 的方法 改玩后的形状 的 元素个数要跟原来的一样 比如原来是10*10 改完后的元素个数必须为100 返回新的tensor

# 可以用于将张量转换为不同的形状，但要确保转换后的形状与原始形状具有相同的元素数量。

def reshape1():

    torch.manual_seed(666)

    t1=torch.rand(20,4)

    # print(t1)

    t2=torch.reshape(t1,(4,20)) # 传入被改的tensor 和形状

    # 可以有一个维度为-1 代表程序自己通过其他维度的元素数量 自己算这个维度的元素数量

    t3=torch.reshape(t1,(40,-1))

    print(t3)

    pass

# 也可以用view变形 tensor的方法

# 这个只能对张量里面的元素是内存连续的 才可以

# 对刚创建出来的tensor进行操作后 就很容易内存不连续 比如转置

# 返回的是原始张量视图，不重新分配内存，效率更高; 比reshape快  这个相当于浅拷贝 不会开新的内存 就是把原来的内存重新排列一下下标

def view1():

    torch.manual_seed(666)

    t1=torch.rand(20,4)

    t2=t1.view(4,20)

    t2[:,-1]=6

    print(t2)

    print(t1)

    pass

# 交换维度 在二维矩阵上像转置一样

# transpose  troch 方法 跟view 一样返回的是原tensor的视图 浅拷贝

# permute tensor 方法 返回一个新的  对维度重新排列 不是浅拷贝

def transpose1():

    torch.manual_seed(666)

    t1=torch.rand(20,4)

    t3=torch.rand(20,4,3)

    t2=torch.transpose(t1,0,1) #  传入tensor和要交换的维度

    t4=torch.transpose(t3,1,2)

    # print(t4.shape)

    t5=t3.permute(1,2,0) # 传入 维度  传入维度的顺序为新的 tensor的维度排序 交换维度

    pass

# tensor展平

# flatten tensor 方法

# flatten 用于将张量展平为一维向量

def flatten1():

    torch.manual_seed(666)

    t1=torch.rand(20,4,3)

    t2=t1.flatten() # 传入开始 展平的层数 和结束展平的层数

    sci()

    print(t2)

    pass

# 升维和降维

# 在后续的网络学习中，升维和降维是常用操作，需要掌握。 tensor 方法 返回新的

# - **unsqueeze**：用于在指定位置插入一个大小为 1 的新维度。 加个[]

# - **squeeze**：用于移除所有大小为 1 的维度，或者移除指定维度的大小为 1 的维度

def squeeze():

    # 降维 一般用于 那些维度的元素数量为1的 直接就删掉了那个维度

    torch.manual_seed(666)

    t1=torch.rand(20,4,3,1,1)

    t2=t1.squeeze() # 传入要删除的维度 默认全部 大小为1 的维度都要删

    print(t2)

    pass

# 升维

def unsqueeze():

    # 升维 在一个维度上 加一个维度 一般都在指定维度的前面

    torch.manual_seed(666)

    t1=torch.rand(20,4,3,1,1)

    t2=t1.unsqueeze(2) # 传入要删除的维度 默认全部 大小为1 的维度都要删

    print(t2.shape)

    pass

# 分割

# 可以按照指定的大小或者块数进行分割。

# chunk  torch方法 按照传入的块数分割 平均 分完后元素的行数个数是平均的 列是最后被分的

# split  按照传入的每一块的元素 的行数分割

# 返回的都是 元组

def split1():

    torch.manual_seed(666)

    t1=torch.rand(20,4)

    t2=torch.chunk(t1,20)

    t3=torch.split(t1,2)

    print(t3[0].shape)

# 广播机制 跟numpy差不多

# 广播机制

# 广播机制允许在对不同形状的张量进行计算，而无需显式地调整它们的形状。广播机制通过自动扩展较小维度的张量，使其与较大维度的张量兼容，从而实现按元素计算。

# 广播机制规则

# 广播机制需要遵循以下规则：

# - 每个张量的维度至少为1

# - 满足右对齐

# 被广播的那个矩阵 的被广播的维度大小为1

 

if __name__=="__main__":

    # reshape1()

    # view1()

    # transpose1()

    # flatten1()

    # squeeze()

    # unsqueeze()

    split1()

    pass