pytorch-1

pytorch

Torch是一个与Numpy类似的张量（Tensor）操作库，与Numpy不同的是Torch对GPU支持的很好，Lua是Torch的上层包装。
PyTorch和Torch使用包含所有相同性能的C库：TH, THC, THNN, THCUNN，并且它们将继续共享这些库。
PyTorch是一个基于Torch的Python开源机器学习库。
PyTorch是一个Python包，提供两个高级功能：

1. 具有强大的GPU加速的张量计算（如NumPy）
2. 包含自动求导系统的的深度神经网络

张量（Tensor）

张量，即tensor，是pytorch中的基本运算单位，与numpy中的ndarray相同是一个多维矩阵，但与ndarray的最大区别是，tensor可以在GPU上运行，大大提高运算速度，而ndarray只能在CPU上运行。
令r为张量的秩或阶，当r=0（第零阶张量）时为标量，当r=1（第一阶张量）时为向量量，当r=2（第二阶张量）时为矩阵，第三阶及以上的张量统称为张量。
张量的基本数据类型有五种：

• 64位浮点型：torch.float32/torch.folat
• 32位浮点型 ：torch.float64/torch.double
• 16位浮点型：torch.float16/torch.half
• 8位无符号整型：torch.uint8
• 64位整型：torch.int64/torch.long
• 32位整型：torch.int32/torch.int
• 16位整型：/torch.int16/torch.short

tensor创建方法：

• 直接创建，即torch.tensor()

torch.tensor(
			data,
			dtype=None,
			device=None,
			requires_grad=False,
			pin_memory=False)
# data:数据，可以是list，numpy
# dtype：数据类型，默认与data一致
# device：所在设备，GPU/CPU
# requires_grad:是否需要梯度
# pin_memory: 是否存于锁页内存
torch.tensor(23)
torch.tensor([1.2,23.0,25.6])
torch.tensor([[1.2,23.0,25.6],[1.2,23.0,25.6]])

• 从numpy创建tensor

torch.from_numpy(ndarray)
# 注：torch.from_numpy创建的tensor与原ndarray共享内存，当修改其中一个数据时，另一个也会被改变。
arr = numpy.array([[1.2,23.0,25.6],[1.2,23.0,25.6]])
t = torch.from_numpy(arr)

• 依据数据创建tensor

# 1 创建全0张量
torch.zeros(
			*size,
			out=None,
			dtype=None,
			latout=torch.strided,
			device=None,
			requires_grad=False)
# size: 张量的形状，如3，3/3，22，22   *size会自动将输入的维度数值打包成元组。
# out：输出的张量
# layout：内存中布局形式，有strided,sparse_coo等
# device：所在设备，CPU/GPU
# requires_grad：是否需要梯度
# dtype：数据类型。

# 2 依据其他数据的形状创建全0张量
torch.zeros_like(
				input,
				dtype=None,
				layout=None,
				device=None,
				requires_grad=False)
# input:创建与input形状一致的全0张量
# dtype： 数据类型
# layout：内存中的布局形式

# 3 创建全1张量
torch.ones(
			*size,
			out=None,
			dtype=None,
			latout=torch.strided,
			device=None,
			requires_grad=False)
torch.ones_like(
				input,
				dtype=None,
				layout=None,
				device=None,
				requires_grad=False)

# 4 依据数值创建全-张量
torch.full(
			size,
			fill_value,
			out=None,
			dtype=None,
			layout=torch.strided,
			device=None,
			requires_grad=False)
# size,张量形状，（）元组输入
# fill_value: 填充张量的值
torch.full_like(
				input,
				fill_value
				)
# 5 创建等差的1维张量
torch.arange(
			start=0,
			end,
			step=1,
			out=None,
			dtype=None,
			layout=torch.strided,
			device=None,
			requires_grad=False)
# 数值区间为 [start，end)  左闭右开
# start：数量起始值
# end：数量结束值（不包括）
# step：数量公差（步长）

# 6 创建均方的1维张量
torch.linspace(
				start,
				end,
				steps=100,
				out=None,
				dtype=None,
				layout=torch.strided,
				device=None,
				requires_grad=False)
# 数值区间维 [start， end] 左闭右闭区间
# start： 数列起始值
# end: 数量结束值（包括）
# steps： 数列长度 
# 其步长为 （end-start）/(steps-1)

# 7 创建对数均分的1维张量
torch.logspace(
				start,
				end,
				steps=100,
				base=10.0,
				out=None,
				dtype=None,
				layout=torch.strided,
				device=None,
				requires_grad=False)
# 数值区间维 [start， end] 左闭右闭区间
# 长度为steps，底为base
# start： 数列起始值
# end: 数量结束值（包括）
# steps： 数列长度 
# base：对数函数的底，默认为10

# 8 创建单位矩阵
torch.eye(
			n,
			m=None,
			out=None,
			dtype=None,
			layout=torch.strided,
			device=None,
			requires_grad=False)
# 创建单位对角矩阵（2维张量）
# n为矩阵行数
# m为矩阵列数

• 依据概率分布创建张量

# 1 正态分布 （高斯分布）
torch.normal(
			mean,
			std,
			out=None)
# mean 均值
# std：标准差
# 四种模式：mean为标量，std为标量；mean为张量，std为标量；mean为标量，std为张量；mean为张量，std为张量

# 2 创建标准正太分布(均值为0，标准差为1)
torch.randn(
			*size,
			out=None,
			dtype=None,
			latout=torch.strided,
			device=None,
			requires_grad=False)

# size:张量的形状
torch.randn_like()

# 3 创建均匀分布
torch.rand(
			*size,
			out=None,
			dtype=None,
			latout=torch.strided,
			device=None,
			requires_grad=False)
torch.rand_like()
# 创建区间为[0, 1)的均匀分布
torch.randint(
				low=0,
				high,
				size,
				out=None,
				dtype=None,
				latout=torch.strided,
				device=None,
				requires_grad=False)
torch.randint_like(
					input,
					low,
					high)
# 在区间[low, high)生成整数均匀分布

# 4 创建伯努利分布
torch.bernoulli(
				input,
				*,
				generator=None,
				out=None)
				
# 以input为概率，生成伯努利分布

# 5 生成随机排列
torch.randperm(
				n,
				out=None,
				dtype=None,
				latout=torch.strided,
				device=None,
				requires_grad=False)
# 生成从0到n-1的随机排列

tensor与variable

variable是torch.autograd中的数据类型，主要用于封装tensor，进行自动求导。
variable的五个属性：

• data：被封装的tensor
• grad：data的梯度
• grad_fn：创建tensor的function，是自动求导的关键
• requires_grad：指示是否需要梯度
• is_leaf：指示是否是叶子结点（张量）

现版本已将variable并于tensor中，
torch.Tensor（）的属性

torch.Tensor和torch.tensor的区别
在Pytorch中，Tensor和tensor都用于生成新的张量。
torch.Tensor()是Python类，更明确的说，是默认张量类型torch.FloatTensor()的别名，torch.Tensor([1,2]) 会调用Tensor类的构造函数__init__，生成单精度浮点类型的张量。
torch.tensor()仅仅是Python的函数

张量操作

• 拼接
  将张量按维度dim进行拼接
  cat不会对tensor的维度进行扩张，stack则会

torch.cat(
			tensors,
			dim=0,
			out=None)
# tensors:张量序列 []
# dim：拼接维度

torch.stack(
			tensors,
			dim=0,
			out=None)
# 在新创建的维度dim上进行拼接

• 切分

torch.chunk(
			input,
			chunks,
			dim=0)
# 将张量按维度dim进行平均切分，返回一张量列表
# 注:若不能整除，最后一份张量小于其他张量
# input: 要切分的张量
# chunks：要切分的分数
# dim：要切分的维度

torch.split(
			tensor,
			split_size_or_sections,
			dim=0)
# 将张量按维度dim进行切分，返回张量列表
# tensor:要切分的张量
# split_size_or_sections: 为int时，表示每份的长度；为list时，按list元素进行切分
# dim：要切分的维度

• 张量索引

torch.index_select(
					input,
					dim,
					index,
					out=None)
# 在维度dim上，按index索引数据返回值即依据index索引数据拼接的张量
# input： 要索引的张量
# dim： 要索引的维度
# index：要索引数据的序号

torch.masked_select(
					input,
					mask,
					out=None)
# 按mask中的True进行索引，返回一维张量
# input： 要索引的张量
# mask：与input同形状的布尔型张量

• 张量变换

torch.reshape(
			input,
			shape)
# 变换张量形状
# input： 要变换的张量
# shape： 新张量的形状
# 注： 当张量在内存中是连续时，新张量与input共享数据内存

torch.transpose(
				input,
				dim0,
				dim1)
# 交换张量的两个维度
# input： 要变换张量
# dim0：交换维度0
# dim1：交换维度1

torch.t(input)
# 2维张量转置

torch.squeeze(
			input,
			dim=None,
			out=None)
# 压缩长度为1的维度（轴）
# dim： 若为None，移除所有长度为1的轴；若指定维度，当且仅当该轴长度为1时进行移除

torch.unsqueeze(
				input,
				dim,
				out=None)
# 依据dim扩展维度
# dim：扩展的维度

张量的数学运算

torch.add(
			input,
			alpha=1,
			other,
			out=None) # 逐元素计算，input+alpha*other

torch.addcdiv(
			input,
			value=1,
			tensor1,
			tensor2,
			out=None)# 逐元素计算，input+value*tensor1/tensor2

torch.addcmul(
			input,
			value=1,
			tensor1,
			tensor2,
			out=None)# 逐元素计算，input+value*tensor1*tensor2