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