Pytorch 函数用法_pytorch detach函数

2023-03-26 07:54:40

list转numpy：numpy.array(list)numpy转list：array.tolist() 创建tensor：torch.zeros()、torch.zeros_like()torch.zeros(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor >>> torch.zeros(2, 3) tensor([[ 0., 0., 0.], [ 0., 0., 0.]]) >>> torch.zeros(5) tensor([ 0., 0., 0., 0., 0.])

返回全0的tensortorch.zeros_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

返回一个和input有相同形状的全零tensor相当于torch.zeros_like(input) is equivalent to torch.zeros(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)

torch.ones()、torch.ones_like()torch.ones(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

和torch.zeros一致，返回的是全1的tensortorch.ones_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

和torch.zeros_like()一致，只不过返回的是全1的tensortorch.arange()torch.arange(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回的是一维tensor，从start开始，到end结束，但取不到end，step可以设置隔几个数取一次numpy中也有类似的函数：numpy.arange()torch.range()torch.range(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor。

torch.range()的性质和torch.arange()一样，只不过torch.arange()是不包含end的，而torch.range()会包含end，pytorch官方文档警告：为了支持torch.arange()，不支持使用此函数。

torch.linspace()torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回一维的tensor，从start到end，按设置的steps划分为steps等分>>> torch.linspace(3, 10, steps=5) tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000]) >>> torch.linspace(start=-10, end=10, steps=1) tensor([-10.])

torch.logspace()torch.logspace(start, end, steps=100, base=10.0, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回一维tensor，从start到end按steps等分，返回的tensor中里面的值为base的start次方到base的end次方，base默认为10>>> torch.logspace(start=-10, end=10, steps=5) tensor([ 1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])

torch.eye()torch.eye(n, m=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回一个二维单位矩阵，只有对角上的值为1，其它位置上的值为0，第一个n决定了tensor是n*n>>> torch.eye(3) tensor([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]])

torch.empty()、torch.empty_like()、torch.empty_strided()torch.empty(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) → Tensor

构造空矩阵张量所谓空张量，就是Storage是原生态没有初始化的内存块，数据是原内存遗留的数据，看起来是随机的PyTorch官网上说返回的tensor是由未初始化的数值构成的torch.empty_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor。

torch.empty_like()返回的是和input一致的size，和torch.zeros_like()的用法一样torch.empty_strided(size, stride, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False) → Tensor。

按照步长构造的张量torch.full()、torch.full_like()torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor。

使用指定值创建的张量比如用3这个指定值去构建一个2*3的tensor，会得到 2*3 的全3 tensortorch.full_like(input, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor。

借助已知张量形状构建填充指定值的张量使用方式和torch.zeros_like()一致对tensor进行连接和分离：torch.cat()torch.cat(tensors, dim=0, out=None) → Tensor。

按照设定的维度拼接两个tensor假如两个4维tensor设定在1维上cat，要求除了1维的维度可以不同，其它三维的维度都必须一致torch.chunk()torch.chunk(input, chunks, dim=0) → List of Tensors。

在给定维度(dim)上将输入张量(input)进行分块儿，chunks参数决定分块的数量torch.split()torch.split(tensor, split_size, dim=0)将输入张量分割成相等形状的chunks（如果可分）。

如果沿指定维的张量形状大小不能被split_size 整分，则最后一个分块会小于其它分块例：a, b = c.split(1, 0) 将c的0维按照长度为1分开torch.squeeze()torch.squeeze(input, dim=None, out=None) → Tensor

去掉input中维度是1的那一维torch.unsqueeze()torch.unsqueeze(input, dim, out=None) → Tensor在指定的维度增加一维，维度数为1torch.stack()。

torch.stack(tensors, dim=0, out=None) → Tensor沿着一个新的维度进行tensor的堆叠，设定的dim代表在哪里新加一个维度所有的tensor要求有相同的维度torch.stack会新增加一个维度，新增加维度的数值和tensor的数目一致。

如两个3*3的tensor (a和b)， c=torch.stack((a, b), 0) c.shape->(2, 3, 3)torch.unbind()torch.unbind(input, dim=0) → seq

移除input中的指定的维度>>> torch.unbind(torch.tensor([[1, 2, 3], >>> [4, 5, 6], >>> [7, 8, 9]])) (tensor([1, 2, 3]), tensor([4, 5, 6]), tensor([7, 8, 9])) 。

原本是(3, 3)，经过移除0维后，得到3个一维的tensor 对tensor进行索引和切片：torch.gather()torch.gather(input, dim, index, out=None, sparse_grad=False) → Tensor

将input按照指定的维度和设定的index(LongTensor)取值，返回一个新的tensort = torch.Tensor([[1,2],[3,4]]) index = torch.LongTensor([[0,0],[1,0]]) torch.gather(t, 1, index) 1 1 4 3 [torch.FloatTensor of size 2x2]。

按照1维取，取出第一行的第0个，第一行的第0个，作为新tensor的第一行，取出第二行的第1个，第二行的第0个，作为新tensor的第二行torch.index_select()torch.index_select(input, dim, index, out=None) → Tensor。

沿着指定维度对输入进行切片，取index中指定的相应项(index为一个LongTensor)，然后返回到一个新的张量，返回的张量与原始张量_Tensor_有相同的维度(在指定轴上)可以根据index在指定的维度上选出自己想要的。

比如index为([0, 2])，在0维上进行此操作，返回的是input的第0行和第2行torch.masked_select()torch.masked_select(input, mask, out=None) → Tensor

根据掩码张量mask中的二元值，取输入张量中的指定项( mask为一个 ByteTensor)，将取值返回到一个新的1D张量，张量mask须跟input张量有相同数量的元素数目，但形状或维度不需要相同mask可以用x.ge(0.5)决定，ge函数可以对x通过阈值0.5返回True(1)或False(0)，mask不可以直接用0或1选择，因为此时0和1不是bool值。

mask中是0或1，代表取哪个数，不取哪个数，所以mask必须和input有相同的元素数量torch.narrow()torch.narrow(input, dim, start, length) → Tensor

可以按照设定的维度(dim)，选择起始位置(start)以及总共选多长(length)torch.nonzero()torch.nonzero(input, *, out=None, as_tuple=False) → LongTensor or tuple of LongTensors

返回一个包含输入input中非零元素索引的张量输出张量中的每行包含输入中非零元素的索引如果输入input有n维，则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。

torch.take()torch.take(input, index) → Tensor根据index取出input中需要的数，index的设定是根据storage的存储方式设的，而不是行列坐标比如input的size是(2, 4)，共8个数，index可以设为torch.tensor([0, 5, 7])，则会从input中取出这3个位置的数。

torch.where()torch.where(condition, x, y) → Tensor在x和y这两个tensor中比较，如果符合condition，就返回x，否则返回y如果x和y的位置互换，则符合条件的就返回y，否则返回x。

torch.where(condition) → tuple of LongTensor对size进行修改：torch.as_strided()torch.as_strided(input, size, stride, storage_offset=0) → Tensor Create a view of an existing torch.Tensor input with specified size, stride and storage_offset

对已有的张量，重新按照其Storage重构张量这个函数仅仅是view的别名函数而已，原理相同torch.reshape()torch.reshape(input, shape) → Tensor根据设定的shape对输入input的size进行修改。

对tensor进行换位：torch.t()torch.t(input) → Tensor希望给定的输入input <= 2维，返回的是转换input的0维和1维位置的tensor相当于矩阵的转置torch.transpose()。

torch.transpose(input, dim0, dim1) → Tensor根据设定的两个维度转换input的维度随机采样（Random Sampling）torch.seed()torch.seed()。

生成一个随机数，返回一个用于为随机生成器设定种子的64位数字torch.manual_seed()torch.manual_seed(seed)设置初始化种子数，seed是想要设定的种子数使用随机数种子后，生成的随机数是相同的。

torch.initial_seed()torch.initial_seed()返回生成随机数的原始种子torch.get_rng_state()torch.get_rng_state()返回随机生成器状态(ByteTensor)

>>> torch.initial_seed() 4 >>> torch.get_rng_state() tensor([4, 0, 0, ..., 0, 0, 0], dtype=torch.uint8)

torch.set_rng_state()torch.set_rng_state(new_state)设定随机生成器状态，new_state是期望的状态torch.bernoulli()torch.bernoulli(input, *, generator=None, out=None) → Tensor

从伯努利分布中抽取二元随机数(0或1)input必须包含用于抽取上述二元随机值的概率，所以input中的数值须控制在[0，1]之间，uniform_(0,1)可以使生成的矩阵中的值都规范在[0,1]范围内

经过torch.bernoulli()得到的输出size和输入的size一致torch.multinomial() 不常用，略torch.multinomial(input, num_samples, replacement=False, out=None) → LongTensor。

multinomial：意为多项的返回一个tensor，每一行包含从input相应行中定义的多项分布中抽取的num_samples个样本torch.normal()torch.normal(mean, std, out=None) → Tensor。

返回一个tensor，包含从给定参数means，std的离散正态分布中抽取随机数mean中包含的是每个元素的均值，std中包含的是每个元素的方差均值和方差的size可以不匹配，但每个tensor的元素个数必须相同。

假如均值设定的是有10个数，那么方差也须给定10个数torch.normal(mean=0.0, std, out=None) → Tensor使用方式和上述函数一致，但是所有元素的均值是共享的torch.normal(mean, std=1.0, out=None) → Tensor。

设定的是方差共享torch.normal(mean, std, size, *, out=None) → Tensori均值和方差都是共享的，最终返回的output的形状按照设定的size输出torch.rand()

torch.rand(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回的tensor是从[0,1)区间均匀分布的随机数值，size是设定的sizetorch.rand_like()torch.rand_like(input, dtype=None, layout=None, device=None, requires_grad=False)→ Tensor

和上述函数一致，只不过output的size是由input决定的，不是直接设定的torch.randint()torch.randint(low=0, high, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

得到的tensor是在low和high之间均匀分布的随机整数tensor得到的数值是随机的，且有可能是重复的torch.randint_like()torch.randint_like(input, low=0, high, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor。

和上述一致，返回的size是按照input的size设定的torch.randn()torch.randn(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回一个由标准正态分布（均值为0，方差为1）随机数组成的tensortorch.randn_like()torch.randn_like(input, dtype=None, layout=None, device=None, requires_grad=False)→ Tensor。

输出size和input的size一致torch.randperm()torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False) → LongTensor

返回的是从0到n-1之间的所有整数，但整数的顺序是打乱的perm代表的是permutation，排列的意思所以和torch.randint()不同，randint返回的并不是所有数，而只是在这一个区间中的整数，有的数可能没出现，有的数又可能出现几次；但是torch.randperm却可以产生在这一区间内所有整数，且每个整数只出现一次。

加载和保存torch.save()torch.save(obj, f, pickle_module=, pickle_protocol=2)

将对象保存在磁盘文件obj是要保存的对象，f是要将此对象保存的位置torch.load()torch.load(f, map_location=None, pickle_module=, **pickle_load_args)

从f这个位置中将保存的对象加载进来数学运算--逐点计算torch.abs()torch.abs(input, out=None) → Tensorout =∣input∣torch.add()torch.add(input, other, out=None)

out=input+othertorch.add(input, other, alpha=1, out=None)out=input+alpha×othertorch.addcdiv()torch.addcdiv(input, value=1, tensor1, tensor2, out=None) → Tensor

input，tensor1 和 tensor2这三个值都应该可以广播torch.addcmul()torch.addcmul(input, value=1, tensor1, tensor2, out=None) → Tensor

input，tensor1 和 tensor2这三个值都应该可以广播torch.mul() torch.mul(input, other, out=None)乘法，other可以是一个标量，也可以是一个tensor

torch.div()torch.div(input, other, out=None) → Tensor除法，返回 input / other 的值，other是一个数，是一个标量torch.div(input, other, out=None) → Tensor

other也可以是一个tensor，input中的每一个元素除以other中的每一个元素input和other都必须可以广播>>> a = torch.randn(4, 4) >>> a tensor([[-0.3711, -1.9353, -0.4605, -0.2917], [ 0.1815, -1.0111, 0.9805, -1.5923], [ 0.1062, 1.4581, 0.7759, -1.2344], [-0.1830, -0.0313, 1.1908, -1.4757]]) >>> b = torch.randn(4) >>> b tensor([ 0.8032, 0.2930, -0.8113, -0.2308]) >>> torch.div(a, b) tensor([[-0.4620, -6.6051, 0.5676, 1.2637], [ 0.2260, -3.4507, -1.2086, 6.8988], [ 0.1322, 4.9764, -0.9564, 5.3480], [-0.2278, -0.1068, -1.4678, 6.3936]])

torch.pow()torch.pow(input, exponent, out=None) → Tensor乘方函数，input的exponent次方，exponent可以是标量，也可以是tensor

torch.neg()torch.neg(input, out=None) → Tensor对所有input取负数 -- -1×inputtorch.reciprocal()torch.reciprocal(input, out=None) → Tensor

取倒数 -- 1 / inputtorch.sqrt()torch.sqrt(input, out=None) → Tensor对input中的每个值开根号torch.rsqrt()torch.rsqrt(input, out=None) → Tensor

input开根号后取倒数

torch.exp()torch.exp(input, out=None) → Tensorinput中的每一个元素作为e的指数，返回torch.expm1()torch.expm1(input, out=None) → Tensor

在上个函数的基础上减一torch.log()torch.log(input, out=None) → Tensor返回以e为底的log函数torch.log2(input, out=None) → Tensor

返回以2为底的log函数torch.log10(input, out=None) → Tensor返回以10为底的log函数torch.log1p()torch.log1p(input, out=None) → Tensor

计算input+1的以e为底的log函数，对于值比较小的输入，此函数比torch.log()更准确torch.floor()torch.floor(input, out=None) → Tensor对输入的tensor的每个元素向下取整

torch.ceil()torch.ceil(input, out=None) → Tensor对输入的tensor的每个元素向下取整后+1，即向上取整torch.round()torch.round(input, out=None) → Tensor

将input中的每个元素都四舍五入到最近的整数torch.clamp()torch.clamp(input, min, max, out=None) → Tensor将输入tensor的每个值都约束到区间[min, max]中，并返回这个tensor。

小于min的重新赋值为min，大于max的重新赋值为max，只有在min和max中间的才会保持原值也可以只设定最小值或最大值，如果只设定最小值，那就把小于最小值的变成最小值，剩下的不变；如果只设定最大值，那就把大于最大值的赋值为最大值，剩下的不变。

torch.trunc()torch.trunc(input, out=None) → Tensor将input中每个元素的小数部分截断torch.fmod()torch.fmod(input, other, out=None) → Tensor

计算除法余数，余数的正负和被除数的正负相同，即和input相同torch.remainder()torch.remainder(input, other, out=None) → Tensor计算除法余数，余数的正负与除数相同，即与other相同

torch.frac()torch.frac(input, out=None) → Tensor返回每个元素的分数部分torch.lerp()torch.lerp(input, end, weight, out=None)

input相当于start，在input和end之间做线性插值

torch.sigmoid()torch.sigmoid(input, out=None) → Tensor

torch.sign()torch.sign(input, out=None) → Tensor符号函数，返回input中每个元素的符号正数返回1，负数返回-1， 0返回0torch.sin()torch.sin(input, out=None) → Tensor。

torch.sinh()torch.sinh(input, out=None) → Tensortorch.asin()torch.asin(input, out=None) → Tensor output=sin−1(input)

torch.cos()torch.cos(input, out=None) → Tensortorch.cosh()torch.cosh(input, out=None) → Tensortorch.acos()

torch.acos(input, out=None) → Tensoroutput=cos−1(input)torch.tan()torch.tan(input, out=None) → Tensor

torch.tanh()torch.tanh(input, out=None) → Tensortorch.atan()torch.atan(input, out=None) → Tensoroutput=tan−1(input)

torch.atan2()torch.atan2(input, other, out=None) → Tensor返回的是input和other两个tensor的反正切函数torch.digamma()

torch.digamma(input, out=None) → Tensor

torch.erf()torch.erf(input, out=None) → Tensor

torch.erfc()torch.erfc(input, out=None) → Tensor

torch.erfinv()torch.erfinv(input, out=None) → Tensor

torch.lgamma()torch.lgamma(input, out=None) → Tensor

torch.mvlgamma()torch.mvlgamma(input, p) → Tensor

torch.polygamma()torch.polygamma(n, input, out=None) → Tensor

数学运算--还原运算torch.prod()torch.prod(input, dtype=None) → Tensor返回input中所有元素的乘积torch.prod(input, dim, keepdim=False, dtype=None) → Tensor

返回输入input中指定维度每行的乘积torch.sum()torch.sum(input, dtype=None) → Tensor返回input中所有元素的和torch.sum(input, dim, keepdim=False, dtype=None) → Tensor

返回input中指定维度每一行所有元素的和torch.argmax()torch.argmax(input) → LongTensor返回input中最大值的索引，假如input是一个4*4的tensor，且其最大值在第一行，第二列，那么其返回的是1（按照在storage中的排列索引）

torch.argmax(input, dim, keepdim=False) → LongTensor返回指定维度中最大值的索引假如设dim=1，则返回每一列中最大值的索引，即0或1或2....torch.argmin()。

torch.argmin(input) → LongTensor返回input里所有值的最小值的索引torch.argmin(input, dim, keepdim=False, out=None) → LongTensor

返回指定维度最小值的索引torch.cumprod()torch.cumprod(input, dim, out=None, dtype=None) → Tensor返回指定维度中，input沿指定维度的累积积，即第几个数即前几个数的乘积

torch.cumsum()torch.cumsum(input, dim, out=None, dtype=None) → Tensor

和torch.cumprod()用法一致，现在是累积和torch.mean()torch.mean(input) → Tensor返回input中所有值的均值torch.mean(input, dim, keepdim=False, out=None) → Tensor

返回input中指定维度中所有值的均值torch.std()torch.std(input, unbiased=True) → Tensor返回input中所有元素的标准差torch.std(input, dim, keepdim=False, unbiased=True, out=None) → Tensor

返回input中指定维度每一行的标准差torch.std_mean()torch.std_mean(input, unbiased=True) -> (Tensor, Tensor)返回input的标准差和均值

torch.std(input, dim, keepdim=False, unbiased=True) -> (Tensor, Tensor)返回input指定维度中每一行的标准差和均值torch.var()

torch.var(input, unbiased=True) → Tensor返回input中所有元素的方差torch.var(input, dim, keepdim=False, unbiased=True, out=None) → Tensor

返回input指定维度中所有维度每一行的方差torch.var_mean()torch.var_mean(input, unbiased=True) -> (Tensor, Tensor)返回input中所有元素的方差和均值

torch.var_mean(input, dim, keepdim=False, unbiased=True) -> (Tensor, Tensor)返回input中指定维度每一行的方差和均值torch.median()

torch.median(input) → Tensor返回input中所有元素的中位数torch.median(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)

返回input中指定维度中所有元素的中位数，并返回其索引torch.mode()torch.mode(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)

和torch.mediam()用法一致，这里是在找指定维度的众数，并返回索引torch.norm()torch.norm(input, p=fro, dim=None, keepdim=False, out=None, dtype=None)

返回input的p范数，也可以设定dim，返回指定维度的p范数torch.dist()torch.dist(input, other, p=2) → Tensor返回 input-other 的p范数input和other一定是可以广播的

torch.unique()torch.unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None)返回input中所有不同的元素。

上面说的是一定会返回的，还有两个是可以选择返回的：inverse_indices (Tensor)和counts(Tensor)inverse_indices返回的是索引，counts返回的是数量需要返回的时候，需要将return_inverse和return_counts设为True。

a = torch.tensor([[2, 3, 3], [0, 1, 2]]) In [29]: b = torch.unique(a) In [30]: b Out[30]: tensor([0, 1, 2, 3]) In [34]: b, inverse_indices, counts = torch.unique(a, return_inverse=True, return_counts=True) In [35]: b Out[35]: tensor([0, 1, 2, 3]) In [36]: inverse_indices Out[36]: tensor([[2, 3, 3], [0, 1, 2]]) In [37]: counts Out[37]: tensor([1, 1, 2, 2])

torch.unique_consecutive()torch.unique_consecutive(input, return_inverse=False, return_counts=False, dim=None)

若张量中的某个数字与其前一数字相同，则删除它使用方式和torch.unique()类似和torch.unique()不同，它只删除连续的重复序列中的值torch.logsumexp()torch.logsumexp(input, dim, keepdim=False, out=None)。

数学运算 -- 比较操作torch.allclose()torch.allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False) → bool

逐个数值比较input和other，如果全部相同，返回True，否则返回Falsetorch.sort()torch.sort(input, dim=-1, descending=False, out=None) -> (Tensor, LongTensor)

对input指定维度中的每一行，按照其值的大小，对其做升序排列，并返回各自的索引torch.argsort()torch.argsort(input, dim=-1, descending=False, out=None) → LongTensor

返回input指定维度中所有值按照升序排列的索引d tensor([[-0.7908, -0.1156, 0.8278], [-1.1141, 0.1938, 2.4251], [-0.3680, 0.3943, -0.1042]]) In [14]: t = torch.argsort(d, dim=0) tensor([[1, 0, 2], [0, 1, 0], [2, 2, 1]])

dim=0的时候，看的是行，即每一行的对应值进行比较，返回比较的索引torch.eq()torch.eq(input, other, out=None) → Tensor对input和other逐元素比较是否相同，返回的tensor由True或False组成。

input和other的同一位置相同的返回True，否则返回Falseother可以是一个数或是一个tensor，other必须是可以广播的In [17]: a = torch.tensor([[0, 3], [4, 5]]) In [19]: b = torch.tensor([[0, 2], [8, 5]]) In [20]: c = torch.eq(a, b) tensor([[ True, False], [False, True]])

torch.equal()torch.equal(input, other) → bool比较input和other是否相同，最后返回True或False，如果input和other中所有的元素都逐元素都相同，返回True，否则返回False

torch.equal()既比较形状，又比较数值torch.ne()torch.ne(input, other, out=None) → Tensor和torch.eq相反，这里是逐元素比较input和other中不相同的元素，如果不相同，返回True，否则返回False

torch.ge()torch.ge(input, other, out=None) → Tensor逐元素比较input和other，看是否 input >= other，如果满足这个条件，则返回True，否则返回False

other可以是一个数，也可以是一个tensor，other是可以广播的torch.le()torch.le(input, other, out=None) → Tensor和torch.ge()用法类似，只不过条件是 input <= other

torch.gt()torch.gt(input, other, out=None) → Tensor和torch.ge()类似，只不过条件是 input > othertorch.lt()torch.lt(input, other, out=None) → Tensor

和torch.ge()类似，只不过条件是 input (Tensor, LongTensor)

对input指定维度中每一行的所有元素返回最大的k个值，由大到小排列，同时还返回其索引torch.kthvalue()torch.kthvalue(input, k, dim=None, keepdim=False, out=None) -> (Tensor, LongTensor)

返回input指定维度中第k个最小的元素，第二个返回的则是这第k个最小值的索引torch.max()torch.max(input) → Tensor返回input中所有元素里的最大值torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)

返回指定维度中每一行里的最大值，并返回其索引torch.max(input, other, out=None) → Tensor逐元素比较input和other，返回其中的最大值，当形状不匹配的时候，返回的输出tensor的形状遵循广播规则

torch.min()torch.min(input) → Tensor torch.min(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor) torch.min(input, other, out=None) → Tensor

和torch.max用法一致，只不过是返回最小值torch.isfinite()torch.isfinite(tensor)返回带有bool值的tensor，用于逐元素判别每个元素是否是有限的torch.isinf()

torch.isinf(tensor)返回一个新的张量，其布尔元素表示每个元素是否为+/-INFtorch.isnan()torch.isnan()返回一个新的张量，其布尔元素表示每个元素是否为NaN数学运算 -- 光谱操作（用不太到，不全）

torch.fft()torch.fft(input, signal_ndim, normalized=False) → Tensor复杂到复杂的傅里叶变换该方法计算复数到复数的离散傅里叶变换

torch.ifft()torch.ifft(input, signal_ndim, normalized=False) → Tensor计算复数到复数的逆离散傅里叶变换

torch.rfft()torch.rfft(input, signal_ndim, normalized=False, onesided=True) → Tensor计算实数到复数离散傅里叶变换数学运算 -- 其它运算（不全）。

torch.cdist()torch.cdist(x1, x2, p=2) → Tensor计算x1和x2每行之间的范数>>> a = torch.tensor([[0.9041, 0.0196], [-0.3108, -2.4423], [-0.4821, 1.059]]) >>> b = torch.tensor([[-2.1763, -0.4713], [-0.6986, 1.3702]]) >>> torch.cdist(a, b, p=2) tensor([[3.1193, 2.0959], [2.7138, 3.8322], [2.2830, 0.3791]])。

比如3.1193是tensor a 的第一行与tensor b 的第一行计算范数得到的结果，2.0959是tensor a 的第一行与tensor b 的第二行计算范数得到的结果，以此类推torch.flatten()。

torch.flatten(input, start_dim=0, end_dim=-1) → Tensor按照起始维度和终止维度，将input展开b = torch.randn(2, 3, 4) tensor([[[ 1.0710, 0.4267, 0.1358, 1.1361], [ 1.1274, 1.4020, 0.9344, -0.1181], [-0.1385, -0.6185, -0.4365, -0.5126]], [[ 0.9602, -0.0765, 0.7859, -2.6319], [ 0.8774, 0.7584, 0.4258, -0.7737], [ 0.0475, 0.8044, -0.4578, 0.5706]]]) In [11]: c = torch.flatten(b, start_dim=1, end_dim=2) tensor([[ 1.0710, 0.4267, 0.1358, 1.1361, 1.1274, 1.4020, 0.9344, -0.1181,-0.1385, -0.6185, -0.4365, -0.5126], [ 0.9602, -0.0765, 0.7859, -2.6319, 0.8774, 0.7584, 0.4258, -0.7737,0.0475, 0.8044, -0.4578, 0.5706]]

torch.flip()torch.flip(input, dims) → Tensor在指定维度对input沿此轴进行翻转torch.rot90()torch.rot90(input, k, dims) → Tensor

对input沿指定维度旋转90度如果k>0，旋转方向是从第一轴转向第二轴；如果k<0，旋转方向是从第二轴转向第一轴torch.histc()torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor。

计算tensor的直方图元素在min和max之间分成相等的宽度区间如果min和max都为0，则使用数据的最小值和最大值torch.meshgrid()torch.meshgrid(*tensors, **kwargs)。

>>> x = torch.tensor([1, 2, 3]) >>> y = torch.tensor([4, 5, 6]) >>> grid_x, grid_y = torch.meshgrid(x, y) >>> grid_x tensor([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) >>> grid_y tensor([[4, 5, 6], [4, 5, 6], [4, 5, 6]])

torch.renorm()torch.renorm(input, p, dim, maxnorm, out=None) → Tensor返回tensor，其中input中指定维度的每个tensor被归一化

torch.combination()torch.combinations(input, r=2, with_replacement=False) → seq将input按照r的长度组合，返回所有种组合的情况。

其功能类似于itertools.combinations()>>> a = [1, 2, 3] >>> list(itertools.combinations(a, r=2)) [(1, 2), (1, 3), (2, 3)] >>> tensor_a = torch.tensor(a) >>> torch.combinations(tensor_a) tensor([[1, 2], [1, 3], [2, 3]])

torch.cross()torch.cross(input, other, dim=-1, out=None) → Tensor返回input和other在指定维度上的向量积(叉积)torch.diag()

torch.diag(input, diagonal=0, out=None) → Tensor如果input是一个一维向量，返回的是一个以input作为对角线的矩阵input作为那条对角线由diagonal决定。

如果input是一个矩阵，返回的是其对角线，返回那个对角线由diagonal决定diagonal=0：主对角线diagonal>0：在主对角线上，数值对应着移动几个位置diagonal<0：在主对角线下，数值对应着移动几个位置。

torch.diag_embed()torch.diag_embed(input, offset=0, dim1=-2, dim2=-1) → Tensortorch.diagflat()torch.diagflat(input, offset=0) → Tensor

如果input是一维的，则返回其对角线为input的矩阵如果input是大于一维的，则先将其拉平成一维，返回拉平的一维输入作为对角线的矩阵offset=0：主对角线offset>0：在主对角线之上offset<0：在主对角线之下

torch.diagonal()torch.diagonal(input, offset=0, dim1=0, dim2=1) → Tensor返回input的局部视图，其对角线元素相对于dim1和dim2作为形状末尾的尺寸附加。

(不是很明白)torch.repeat_interleave()torch.repeat_interleave(input, repeats, dim=None) → Tensor与torch.repeat()不同，但是和numpy.repeat()类似

>>> x = torch.tensor([1, 2, 3]) >>> x.repeat_interleave(2) tensor([1, 1, 2, 2, 3, 3]) >>> y = torch.tensor([[1, 2], [3, 4]]) >>> torch.repeat_interleave(y, 2) tensor([1, 1, 2, 2, 3, 3, 4, 4]) >>> torch.repeat_interleave(y, 3, dim=1) tensor([[1, 1, 1, 2, 2, 2], [3, 3, 3, 4, 4, 4]]) >>> torch.repeat_interleave(y, torch.tensor([1, 2]), dim=0) tensor([[1, 2], [3, 4], [3, 4]])

如果repeats不是数，而是tensor，如torch.tensor([1, 2])，dim=0，则代表第一行重复一次，第二行重复两次torch.repeat_interleave(repeats) → Tensor。

torch.roll()torch.roll(input, shifts, dims=None) → Tensor对input沿指定维度滚动shifts可以是整数，也可以是tuple，tuple和dims是相对应的

>>> torch.roll(x, shifts=(2, 1), dims=(0, 1)) tensor([[6, 5], [8, 7], [2, 1], [4, 3]])

torch.tensordot()torch.tensordot(a, b, dims=2)可以表示任意多维，任意组合形式的矩阵相乘torch.trace()torch.trace(input) → Tensor

返回二维矩阵对角线上所有元素的和torch.tril()torch.tril(input, diagonal=0, out=None) → Tensor删除矩阵中部分三角部分元素，如果diagonal=0，则删除上三角元素，如果diagonal=1，则删除在主对角线之上一个对角线上的元素

>>> torch.tril(b, diagonal=1) tensor([[ 1.2219, 0.5653, 0.0000, 0.0000, 0.0000, 0.0000], [ 0.4785, -0.4477, 0.6049, 0.0000, 0.0000, 0.0000], [ 1.1502, 3.2716, -1.1243, -0.5413, 0.0000, 0.0000], [-0.0614, -0.7344, -1.3164, -0.7648, -1.4024, 0.0000]])

torch.triu()torch.triu(input, diagonal=0, out=None) → Tensor和torch.tril()相反，删除矩阵的下三角部分，对角线由diagonal决定

>>> torch.triu(a, diagonal=1) tensor([[ 0.0000, 0.5207, 2.0049], [ 0.0000, 0.0000, 0.6602], [ 0.0000, 0.0000, 0.0000]])

torch.tril_indices()torch.tril_indices(row, col, offset=0, dtype=torch.long, device=cpu, layout=torch.strided)→ Tensor

pytorch1.0新添加的，与numpy功能类似，不熟悉torch.triu_indices()torch.triu_indices(row, col, offset=0, dtype=torch.long, device=cpu, layout=torch.strided)→ Tensor

和torch.tril_indices()类似torch.einsum()torch.einsum(equation, *operands) → Tensor该函数提供了一种使用爱因斯坦求和约定来计算多线性表达式（即乘积和）的方法。

数学运算 -- BLAS和LAPACK操作torch.mm()torch.mm(input, mat2, out=None) → Tensorinput和mat2都要求是2维的，返回input和mat2做矩阵乘积的结果

torch.matmul()torch.matmul(input, other, out=None) → Tensor类似于torch.mm()的高维版本或广播版本input和other可以不一定非得是2维的，假如input是2维的，other是3维的，input可以被广播成3维的，再与mat2进行矩阵相乘

torch.bmm()torch.bmm(input, mat2, out=None) → Tensorinput和mat2进行batch级别的矩阵相乘input和mat2都是3维的torch.addbmm()

torch.addbmm(beta=1, input, alpha=1, batch1, batch2, out=None) → Tensor对batch级别的矩阵进行矩阵相乘，相乘后的结果按照第一维度累计相加，最后再将input加到最后的结果中。

batch1和batch2是3维的，第一维是batch size，batch1和batch2的这一维应该是相同的，按照每一个batch两两相乘后，再将其按照batch相加，最后得到的是每一个batch在此位置上的累积和。

假如batch1的size为(10, 2, 3)和batch2的size为(10, 3, 2)，再相乘后的结果output1的size为(2, 2)；input的size也应为(2, 2)，将output1的结果与alpha相乘，再将其与β×input的结果相加。

torch.addmm()torch.addmm(beta=1, input, alpha=1, mat1, mat2, out=None) → Tensor和torch.addbmm()类似，只不过这里的mat1和mat2是二维的，即只对一个batch做矩阵相乘

output = β × input + alpha ×（mat1 × mat2）torch.addmv()torch.addmv(beta=1, input, alpha=1, mat, vec, out=None) → Tensor

与torch.addmm()类似，只不过将mat2替换为vec（一个一维向量），所以这里是对矩阵和向量做矩阵向量乘积，其结果仍旧和input相加output = β × input + alpha ×（mat × vec）。

torch.addr()torch.addr(beta=1, input, alpha=1, vec1, vec2, out=None) → Tensor对vec1和vec2做叉积(外积)运算，与alpha相乘后将其结果再与β×input的结果相加

torch.baddbmm()torch.baddbmm(beta=1, input, alpha=1, batch1, batch2, out=None) → Tensor在batch1和batch2中执行批量的矩阵之间的乘积，最终的结果是

output = β × input + alpha ×（batch1 × batch2）和torch.addbmm()相同的是，都是进行batch级别的矩阵相乘，但是torch.addbmm()多了个按照第一维度求累积和的步骤，torch.baddbmm()是没有这一步的，batch1和batch2作为3维tensor做矩阵相乘，相乘后的结果和alpha再相乘，此时仍是3维的，input要求是可广播的，可以广播成3维

torch.chain_matmul()torch.chain_matmul(*matrices)N 个二维矩阵连续相乘>>> a = torch.randn(3, 4) >>> b = torch.randn(4, 5) >>> c = torch.randn(5, 6) >>> d = torch.randn(6, 7) >>> torch.chain_matmul(a, b, c, d) tensor([[ -2.3375, -3.9790, -4.1119, -6.6577, 9.5609, -11.5095, -3.2614], [ 21.4038, 3.3378, -8.4982, -5.2457, -10.2561, -2.4684, 2.7163], [ -0.9647, -5.8917, -2.3213, -5.2284, 12.8615, -12.2816, -2.5095]])

torch.dot()torch.dot(input, tensor) → Tensor计算input和tensor之间的点积这个功能不广播torch.get()torch.ger(input, vec2, out=None) → Tensor

计算input和vec2的外积torch.inverse()torch.inverse(input, out=None) → Tensor返回input的逆矩阵torch.det()torch.det(input) → Tensor

返回input的行列式torch.mv()torch.mv(input, vec, out=None) → Tensor矩阵input和向量vec相乘，如果input的size是(n, m)，vec的size为(m)，则输出的size为(n)

torch.eig()torch.eig(input, eigenvectors=False, out=None) -> (Tensor, Tensor)计算实方阵input的特征值和特征向量Parameters

torch.nn.Parameters()self.v = torch.nn.Parameter(torch.FloatTensor(hidden_size))将一个固定不可训练的tensor转换成可以训练的类型parameter，并将这个parameter绑定到这个module里（net.parameter()中就有这个绑定的parameter，所以在参数优化的时候可以进行优化）

经过这个类型转换后，self.v就转换成了模型的一部分，成为模型中根据训练可以改动的参数使用这个函数的目的也是想让某些变量在学习的过程中不断修改其值，以达到最优化在训练网络的时候，可以用nn.Parameters()来转换一个固定的权重数值，使其可以跟着网络训练一直调优下去，学习到一个最适合的权重值。

一般来说，pytorch的Parameter是一个tensor，但跟通常意义上的tensor不太一样通常意义上的tensor仅仅是数据，而Parameter所对应的tensor除了包含数据之外，还包含一个属性：requires_grad=(True/False)。

如果想在Parameter中获得纯数据，可以通过para_data = Parameter.data

以上就是关于《Pytorch 函数用法_pytorch detach函数》的全部内容，本文网址：https://www.7ca.cn/baike/8215.shtml，如对您有帮助可以分享给好友，谢谢。

标签:

声明

Pytorch 函数用法_pytorch detach函数

目录：

1.pytorch的detach函数

2.pytorch函数说明

3.pytorch function

4.pytorchhook函数

5.pytorchview函数

6.pytorch criterion函数

7.pytorch functional

8.pytorch detach().numpy()

9.pytorch scatter_函数

10.pytorch函数大全