PyTorch基础介绍

 t=torch.tensor([1,2,3])  #定义张量，输出的话是“tensor([1,2,3])”，因为默认是使用CPU，不更改的话，后期的操作都是在CPU上执行
 t=t.cuda()  #将t转移到GPU上，输出的话是“tensor([1,2,3],device='cuda:0')”，后面是设备的编号“cuda:0”，pytorch支持多个GPU

dd=[
 [1,2,3],
 [4,5,6],
 [7,8,9]
 ]
t=torch.tensor(dd)  #将dd转化成张量，输出t的话是“tensor(......)”
type(t)  #输出的类型是“torch.Tensor”
t.shape  #输出的结果是“torch.Size([3,3])”
t.reshape(1,9)  #输出的结果是“tensor([[1,2,3,4,5,6,7,8,9]])”，注意重塑时分量值的乘积必须等于张量中元素的总数，保证张量数据结构中有足够位置来包含重组后的所有原始元素
t.reshape(1,9).shape  #输出的结果是“torch.Size([1,9])”

import torch
 import numpy as np
 t = torch.Tensor()
 type(t)  #输出的结果是“torch.Tensor”
 print(t.dtype)  #输出的结果是“torch.float32”
 print(t.device)  #输出的结果是“cpu”
 print(t.layout)  #输出的结果是“torch.strided”
 device = torch.device('cuda:0')
 device  #输出的结果是“device(type='cuda' , index=0)”

data = np.array([1 , 2 , 3])
type(data)  #输出的结果是“numpy.ndarray”
torch.Tensor(data)  #输出的结果是“tensor([1. , 2. , 3.])”，因为这是一个构造类函数
torch.tensor(data)  #输出的结果是“tensor([1 , 2 , 3] , dtype=torch.int32)”，因为这是一个工厂函数
torch.as_tensor(data)  #输出的结果是“tensor([1 , 2 , 3] , dtype=torch.int32)”，因为这是一个工厂函数
torch.from_numpy(data)  #输出的结果是“tensor([1 , 2 , 3] , dtype=torch.int32)”，因为这是一个工厂函数
torch.eye(2)  #创建单位张量（对角线为1.，其余为0.），参数为行数
torch.zeros(2,2)  #创建一个2*2的全是0.的张量
torch.ones(2,2)  #创建一个2*2的全是1.的张量
torch.rand(2,2)  #创建一个2*2的全是随机数的张量

torch.get_default_dtype()  #输出的结果是“torch.float32”，所以构造函数是用的全局缺省值
torch.tensor(np.array([1 , 2 , 3]))  #输出的结果是“tensor([1 , 2 , 3] , dtype=torch.int32)”
torch.tensor(np.array([1. , 2. , 3.]))  #输出的结果是“tensor([1. , 2. , 3.] , dtype=torch.float64)”
torch.tensor(np.array([1 , 2 , 3]) , dtype=torch.float64)  #输出的结果是“tensor([1. , 2. , 3.] , dtype=torch.float64)”
data = np.array([1 , 2 , 3])
t1 = torch.Tensor(data)  #这是在内存中创建了一个额外的输入数据副本，是一个copy
t2 = torch.tensor(data)  #这是在内存中创建了一个额外的输入数据副本，是一个copy
t3 = torch.as_tensor(data)  #这是在内存中共享数组的数据，是一个share
t4 = torch.from_numpy(data)  #这是在内存中共享数组的数据，是一个share
data[0] = 0
data[1] = 0
data[2] = 0  #改变原始数组的值
print(t1)  #输出的结果是“tensor([1. , 2. , 3.])”
print(t2)  #输出的结果是“tensor([1 , 2 , 3] , dtype=torch.int32)”
print(t3)  #输出的结果是“tensor([0 , 0 , 0] , dtype=torch.int32)”
print(t4)  #输出的结果是“tensor([0 , 0 , 0] , dtype=torch.int32)”

t = torch.tensor([
 [1 , 1 , 1 , 1] ,
 [2 , 2 , 2 , 2] ,
 [3 , 3 , 3 , 3]
 ] , dtype = torch.float32)
 torch.tensor(t.shape).prob()  #输出的结果是“tensor(12)”
 t.numel()  #输出的结果是“12”，计算的是元素的数量（在不改变秩的情况下，重塑可以是1*12，2*6，3*4，6*2和12*1）
 t.reshape(2 , 2 , 3)  #输出的结果是“tensor([[[1. , 1. , 1.],[1. , 2. , 2.]],[[2. , 2. , 3.],[3. , 3. , 3.]]])”（秩不同的情况下，也能重塑，用压缩squeezing和解压unsqueezing）
 print(t.reshape(1 , 12))  #输出的结果是“tensor([[1. , 1. , 1. , 1. , 2. , 2. , 2. , 2. , 3. , 3. , 3. , 3.]])”
 print(t.reshape(1 , 12).shape)  #输出的结果是“torch.Size([1 , 12])”
 print(t.reshape(1 , 12).squeeze()) #输出的结果是“tensor([1. , 1. , 1. , 1. , 2. , 2. , 2. , 2. , 3. , 3. , 3. , 3.])”
 print(t.reshape(1 , 12).squeeze().shape)  #输出的结果是“torch.Size([12])”
 print(t.reshape(1 , 12).squeeze().unsqueeze(dim=0))  #输出的结果是“tensor([[1. , 1. , 1. , 1. , 2. , 2. , 2. , 2. , 3. , 3. , 3. , 3.]])”
 print(t.reshape(1,12).squeeze().unsqueeze(dim=0).shape)  #输出的结果是“torch.Size([1 , 12])”

 def flatten(t):
 t = t.reshape(1 , -1)
 t = t.squeeze()
 return t
 flatten(t)  #输出的结果是“tensor([1. , 1. , 1. , 1. , 2. , 2. , 2. , 2. , 3. , 3. , 3. , 3.])”
 t1 = torch.tensor([
 [1 , 2]
 ])
 t2 = torch.tensor([
 [3 , 4]
 ])
 torch.cat((t1 , t2) , dim=0)  #输出的结果是“tensor([[1 , 2], [3 , 4]])” 张量的连接，dim=1时，输出的结果为“tensor([[1 , 2 , 3 , 4]])”

 t.reshape(1 , -1)[0]
 t.reshape(-1)
 t.view(t.numel())
 t.flatten()
 t.flatten(start_dim=1).shape  #输出的结果是“torch.Size([3 , 16])”原始是[3 , 1 , 4 , 4]
 t.flatten(start_dim=1) #输出的结果是“tensor([[1 , 1 , 1 ,......] ,  [2 , 2 , 2 ,......] , [3 , 3 , 3 ,......]])” start_dim告诉flatten的操作从哪个轴开始，1表示从第2个轴开

 import torch
 import numpy as np
 t = torch.tensor([
 [0 , 1 , 0],
 [2 , 0 , 2],
 [0 , 3 , 0]
 ],dtype=torch.float32)
 t.sum() #输出的结果是“tensor(8.)”
 t[0].sum() #输出的结果是“tensor(1.)”，即为第一行的和
 t.numel() #输出的结果是“9”
 t.sum().numel() #输出的结果是“1”
 t.sum().numel() < t.numel() #输出的结果是“True”
 t.prob() #输出的结果是“tensor(0.)”
 t.mean() #输出的结果是“tensor(0.8889)”
 t.std() #输出的结果是“tensor(1.1667)”
 t.sum(dim = 0) #输出的结果是“tensor([2 , 4 , 2])”，先竖再横，0表示竖着
 t.sum(dim = 1) #输出的结果是“tensor([1 , 4 , 3])” 
 
 #例子2：
 t = torch.tensor([
 [1 , 0 , 0 , 2],
 [0 , 3 , 3 , 0],
 [4 , 0 , 0 , 5]
 ] , dtype=torch.float32)
 t.max() #输出的结果是“tensor(5.)”
 t.argmax() #输出的结果是“tensor(11)”
 t.flatten() #输出的结果是“tensor([1. , 0. , 0. , 2. , 0. , 3. , 3. , 0. , 4. , 0. , 0. , 5.])”在平坦张量中5的索引就是11
 t.max(dim = 0) #输出的结果是“(tensor([4. , 3. , 3. , 5.]), tensor([2 , 1 , 1 , 2]))”
 t.argmax(dim = 0) #输出的结果是“tensor([2 , 1 , 1 , 2])”
 t.max(dim = 1) #输出的结果是“(tensor([2. , 3. , 5.]), tensor([3 , 1 , 3]))”
 t.argmax(dim = 1) #输出的结果是“tensor([3 , 1 , 3])”
 t.mean() #输出的结果是“tensor(5.)”
 t.mean().item() #输出的结果是“5.0”，但是item只适用于标量值张量
 t.mean(dim = 0).tolist() #输出的结果是“[1.7 , 1.0 , 1.0 , 2.3]”
 t.mean(dim = 0).numpy() #输出的结果是“array([1. , 1. , 1. , 2.],dtype = float32)”

 import torch #torch是顶级的pytorch包和张量库
 import torchvision #torchvision是一个提供对数据集、模型架构和计算机视觉的图像转换的访问的包（需要单独安装）
 import torchvision.transforms as transforms #这个接口是负责访问图像处理的通用转换
 #创建一个实现这些所需方法（两种）的子类来拓展数据集类，这样新self类能够传递给pytorch data loader对象构造器，并将数据集包装起来来提供额外的功能
 class OHLC(Dataset):
  def _init_(self , csv_file):
   self.data = pd.read_csv(csv_file)
  def _getitem_(self , index): #从数据集中的一个特定索引位置获取一个元素
   r = self.data.iloc[index]
   label = torch.tensor(r.is_up_day , dtype = torch.long)
   sample = self.normalize(torch.tensor([r.open , r.high , r.low , r.close]))
   return sample , label
  def _len_(self):
   return len(self.data) #长度方法，返回数据集长度
  #使用torchvision获得一个fashion－mnist数据集的实例
  
 train_set = torchvision.datasets.FashionMNIST(
 root = './data/FashionMNIST' #这个是路径，即数据所在的硬盘位置
 ,train = True #一个训练的参数，意味着希望数据用于训练
 ,download = True #意思是如果没有出现在指定的根目录下，可以下载这些数据
 ,transform = transform.Compose([
 transforms.ToTensor()
 ]) #一个变换参数，想要把图像变换成张量（为了使用在类定义中的url从web中提取出原始数据，对于转换将原始图片数据使用两个张量转换对象转换成一个张量）
 )
 train_loader = torch.utils.data.DataLoader(train_set) #意思是在数据加载器对象实例中封装数据，然后可以用加载器来完成一些任务（大量的批处理、线程管理和shuffle功能），数据加载器能够访问数据并提供查询功能
 #也可以指定批处理的大小（默认是1）
 #train_loader = torch.utils.data.DataLoader(train_set , batch_size = 10)
 
 import numpy as np
 import matplotlib.pyplot as plt
 
 torch.set_printoptions(linewidth = 120) #只是设置一下行距
 len(train_set) #查看训练集长度，长度是60000
 train_set.train_labels #查看各个数据的标签（每个数字代表不同的类别），输出的结果是“tensor[9 , 0 , 0 , ... , 3 , 0 , 5]”
 train_set.train_labels.bincount() #bincount可以查看一个张量内值得频率分布，输出的结果是“tensor[6000 , 6000 , 6000 , 6000 , 6000 , 6000 , 6000 , 6000 , 6000 , 6000]”，均匀分布
 #把数据单独拿出来看一下
 sample = next(iter(train_set)) #从训练集里面抽取数据
 len(sample) #求取数据的长度，输出的结果是“2”，因为一个是图片张量一个是标签张量
 type(sample) #样本是一个Python的序列类型，输出的结果是“tuple”元组
 image , label = sample #使用序列解压缩的概念来分配图像和标签
 image.shape #查看图片的形状，输出的结果是“torch.Size([1 , 28 , 28])”，灰度图只有一个颜色通道的图像
 label.shape #查看标签的形状，输出的结果是“torch.Size([])”，因为标签是一个标量值，所以输出一个没有形状的标量张量
 plt.imshow(image.squeeze(), cmap = 'gray')
 
 print('label:' , label) #将图像和标签打印出来
 
 batch = next(iter(train_loader)) #批量处理数据加载器
 len(batch) #输出的结果是“2”
 type(batch) #输出的结果是“list”
 images , labels = batch #因为是批处理，所以是复数形式
 images.shape #查看批量图片的形状，输出的结果是“torch.Size([10 , 1 , 28 , 28])”，灰度图只有一个颜色通道的图像
 labels.shape #查看批量标签的形状，输出的结果是“torch.Size([10])”，因为标签是一个标量值，所以输出一个没有形状的标量张量
 grid = torchvision.utils.make_grad(images , nrow = 10) #设置nrow是将十个图片沿着一行显示
 plt.figure(figsize=(15 , 15)) 
 plt.imshow(np.transpose(grid , (1 , 2 , 0)))
 
 print('labels:' , labels) #输出图片以及标签

class Lizard:
 def _init_(self , name): #构造函数，self参数能够创建存储或封装在类对象的属性值
  self.name = name #调用函数时，并没有通过参数来传递self参数，Python幕后自动做了
 def set_name(self , name): #另外可以创建任意数量的自定义方法，然后可以调用这个方法，并为这个名称传递一个新的值
  self.name = name
  #调用
lizard = Lizard('deep')
print(lizard.name) #输出的结果是“deep”
lizard.set_name('lizard')
print(lizard.name) #输出的结果是“lizard”

class Network: #简单的神经网络
 def _init_(self):
  self.layer = None #构造一个虚拟层，并为前向函数提供一个虚拟的实现
  def forward(self , t): #向前函数使用了张量t
  t = self.layer(t) #并使用虚拟层对其进行转换
  return t #在使用虚拟层进行张量变换后，再返回张量t
  
import torch.nn as nn

class Network(nn.Module): #指定nn.Module类，引入nn.Module来构造pytorch神经网络
 def _init_(self):
  super(Network , self)._init() #加入超级类构造函数的调用，可以保持追踪每个层中包含的网络权重
  #添加线性层和卷积层
  self.conv1 = nn.Conv2d(in_channels=1 , out_channels=6 , kernel_size=5) #参数有三
  self.conv2 = nn.Conv2d(in_channels=6 , out_channels=12 , kernel_size=5)
  #当从卷积层转换到线性层时，必须将张量变平
  self.fc1 = nn.Linear(in_features=12*4*4 , out_features=120) #12来自上一层的输出通道数量
  self.fc2 = nn.Linear(in_features=120 , out_features=60) #线性层也叫全连接层（也叫dense），所以是FC
  self.out = nn.Linear(in_features=60 , out_features=10) #参数有俩
 def forward(self , t): #向前函数使用了张量t
  #执行前向传输，有他妈的bug
  return t #在使用虚拟层进行张量变换后，再返回张量t

 class Network(nn.Module): #指定nn.Module类，引入nn.Module来构造pytorch神经网络
  def _init_(self):
   super(Network , self)._init() #加入超级类构造函数的调用，可以保持追踪每个层中包含的网络权重
   #添加线性层和卷积层
   self.conv1 = nn.Conv2d(in_channels=1 , out_channels=6 , kernel_size=5) #参数有三
   self.conv2 = nn.Conv2d(in_channels=6 , out_channels=12 , kernel_size=5)
   #当从卷积层转换到线性层时，必须将张量变平
   self.fc1 = nn.Linear(in_features=12*4*4 , out_features=120) #12来自上一层的输出通道数量
   self.fc2 = nn.Linear(in_features=120 , out_features=60) #线性层也叫全连接层（也叫dense），所以是FC
   self.out = nn.Linear(in_features=60 , out_features=10) #参数有俩
  def forward(self , t): #向前函数使用了张量t
   net = Network()
 print(network)