torch学习笔记1

pytorch 0.3.0中文文档:

http://pytorch.apachecn.org/cn/tutorials/index.html

sklearn中的数据可视化tsne:
https://www.deeplearn.me/2137.html

http://bindog.github.io/blog/2016/06/04/from-sne-to-tsne-to-largevis/

##1.torch.cat()进行tensor的拼接
```
import torch

a = torch.ones([1,2])

b = torch.ones([1,2])

torch.cat([a,b],1)

1 1 1 1

[torch.FloatTensor of size 1x4]
```
如果第二个参数是1，`torch.cat`就是将a,b 按列放在一起，大小为`torch.Size([1,4])`。如果第二个参数是0，则按行

行放在一起，大小为 `torch.Size([2, 2])` 。

第二个参数默认是`0`
注意：拓展的理解，第二个参数dim代表拼接在一起的维度，其他维度必须保持一致：
```
frac1=torch.ones(2,3,8,5)
frac2=torch.zeros(2,3,2,5)
torch.cat((frac1,frac1,frac2),dim=2) #其他维度不一致会出错，可以多个一起拼接
```
```
torch.cat(seq,dim=0,out=None) # 沿着dim连接seq中的tensor, 所有的tensor必须有相同的size或为empty， 其相反的操作为 torch.split() 和torch.chunk()
torch.stack(seq, dim=0, out=None) #同上
```
```
 #注: .cat 和 .stack的区别在于 cat会增加现有维度的值,可以理解为`续接`，stack会新加增加一个维度(多一个大括号，包起来)，可以理解为`叠加`

>>> a=torch.Tensor([1,2,3])
>>> torch.stack((a,a)).size()
torch.size(2,3)
>>> torch.cat((a,a)).size()
torch.size(6)
```

自己的一点体会：

在深度学习处理图像的时候，经常要考虑将多张不同图片输入到网络，这时需要用torch.cat([image1,image2],1), 第二个参数是1；

如果将多个颜色通道拼成一张图片，比如将L, A, B三通道或R, G, B三通道组合成一张彩色图片，此时应用torch.cat([L,A,B,].0)，第二个参数为0.

---------------------

本文来自 my-GRIT 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/qq_39709535/article/details/80803003?utm_source=copy

##2.torch.normal()
返回一个张量，包含从给定参数means,std的离散正态分布(默认标准正态分布)中抽取随机数。 均值means是一个张量，包含每个输出元素相关的正态分布的均值。 std是一个张量，包含每个输出元素相关的正态分布的标准差。 均值和标准差的形状不须匹配，但每个张量的元素个数须相同。

>参数:
means (Tensor) –均值(如果均值为一个数字,则所有数据共享均值,均值一样,标准差也是一样可以共用)
std (Tensor)  –  标准差
out (Tensor)  –  可选的输出张量
例子:
```
torch.normal(mean=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))#以前版本可以这样,但是现在arange产生的是LongTensor类型的,需要转换成FloatTensor才行
tensor([ 0.0222,  2.5456,  3.6517,  3.5567,  4.9916,  5.5173,  6.9699,  7.8141,
         8.9292, 10.0063])
```
现在arange产生的是LongTensor类型的,需要转换成FloatTensor才行,修改为:
```
torch.normal(torch.arange(1, 11).type(torch.FloatTensor), torch.arange(1, 0, -0.1).type(torch.FloatTensor))
```
尽管如此，torch.Tensor、torch.rand、torch.randn 依然均默认生成 torch.FloatTensor型 ：
##3.arange与linspace的区别:

arange()类似于内置函数range()，通过指定开始值、终值和步长创建表示等差数列的一维数组，注意得到的结果数组不包含终值,默认的步长是1。
```
import torch
torch.arange(1, 0, -0.1) #步长为负数,代表逆向,且起始点大于结束点

tensor([1.0000, 0.9000, 0.8000, 0.7000, 0.6000, 0.5000, 0.4000, 0.3000, 0.2000,
        0.1000])
```
```
import torch
torch.arange(1, 11, 2)#可以看出,不包括右边界,[1,11)

tensor([1, 3, 5, 7, 9])

```

linspace()通过指定开始值、终值和元素个数创建表示等差数列的一维数组，可以通过endpoint参数指定是否包含终值，默认值为True，即包含终值。

```
import torch
torch.linspace(1,10,5)

tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])

```

##4.取最值,以及比较
###4.1.torch.max():
torch.max(input)： 返回输入元素的最大值
torch.max(input,other):返回一个张量,input与other相比较,取较大值形成tensor
torch.min(input)： 返回输入元素的最小值,与max类似
torch.max(input) → Tensor,返回输入tensor中所有元素的最大值
```
a = torch.randn(1, 3)
>>0.4729 -0.2266 -0.2085

torch.max(a)
>>0.4729

```
torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)

按维度dim 返回最大值

torch.max(a,0) 返回每一列中最大值的那个元素，且返回索引（返回最大元素在这一列的行索引）;
torch.max(a,1) 返回每一行中最大值的那个元素，且返回其索引（返回最大元素在这一行的列索引）

```
a=torch.tensor([[1,2,3],[7,9,5]])
torch.max(a,1)
(tensor([3, 9]), tensor([2, 1]))
```
```
a=torch.tensor([[1,2,3],[7,9,5]])
torch.max(a,1)
(tensor([7, 9, 5]), tensor([1, 1, 1]))

```
torch.max()[0]， 只返回最大值的每个数

troch.max()[1]， 只返回最大值的每个索引

torch.max()[1].data 只返回variable中的数据部分（去掉Variable containing:）

torch.max()[1].data.numpy() 把数据转化成numpy ndarry

torch.max()[1].data.numpy().squeeze() 把数据条目中维度为1 的删除掉

作者：摇摆的果冻 
来源：CSDN 
原文：https://blog.csdn.net/Z_lbj/article/details/79766690 
版权声明：本文为博主原创文章，转载请附上博文链接！

###4.2
torch.equal(torch.Tensor(a), torch.Tensor(b))：两个张量进行比较，如果相等返回true，否则返回false

torch.ge(input,other,out=none) 
torch.ge(torch.Tensor(a),torch.Tensor(b))   
>比较内容：
ge: input>=other  也就是a>=b, 返回true，否则返回false
gt: input> other    也就是a>b, 返回true，否则返回false
lt: input< other    也就是a< b,返回true，否则返回false
##5.乘法
x，y都是tensor
r=torch.mm(x,y):线性代数中的矩阵乘法，维度必须满足“首尾相接”;
r=torch.mul(x,y)  :对应位置相乘，返回值也是tensor
r=numpy.dot(x,y)   : 线性代数中的矩阵乘法(等于r=x.dot(y))
a*b     :a,b是ndarray类型,对应位置相乘

##6.expand方法
```
a = torch.ones(1)
print(a.shape)
b = a.expand(6)  //扩展自身
print(b)
```
输出:
```
tensor([1., 1., 1., 1., 1., 1.])
```

##7.广播法则
```
 # 1.所有数组向shape最长的数组看齐，不足的在前方补一(特别的,对于只有一个维度的tensor,这个维度相当于最后一个维度,比如ten=torch.tensor([1,2,3]),其size为(3,),那么与(2,2,3)的tensor进行匹配时,ten的size要先变为(1,1,3))
 # 2.两个数组要么在某个维度长度一致，要么一个为一，否则不能计算
 # 3.对长度为一的维度，计算时复制元素扩充至和此维度最长数组一致
 #最后,将两个tensor分别扩展至最大维度后,再进行计算即可

a = torch.ones(3,2)
b = torch.ones(2,3,1)
print(a + b) 
```
结果:a+b的size: (2,3,2)
```
tensor([[[2., 2.],
         [2., 2.],
         [2., 2.]],

[[2., 2.],
         [2., 2.],
         [2., 2.]]])

```

##8.数组和Tensor内存共存
```
import numpy as np
 
# 数组和Tensor互换
a = torch.ones(2,3)
b = a.numpy()
c = torch.from_numpy(b)
c[0,0] = 0
print(a)   #会发现a也改变了

```
##9.tensor的size()方法:
x.view(x.size(0), -1)的解释:
莫烦的pytorch教程中，用cnn实现mnist的分类。其中class中有一段代码：
```
def forward(self, x):
   x = self.conv1(x) 
   x = self.conv2(x) #x的size为50 * 32 * 7 *7     t = x.size(0) 0->50,1->32,2->7,3->7
   x = x.view(x.size(0), -1) # flatten the output of conv2 to (batch_size, 32 * 7 * 7)
   output = self.out(x)
return output, x # return x for visualization

```
这里的x.size(0),0是指的dim=0,相当于x.size(dim=0), 另外,也相当于x.size()[0],因为size()返回的是tuple,第0个则代表dim=0上的值
```
import torch
import numpy as np

x=torch.tensor([1,2,3,4,5,6,7,8,9,9,9,9]).reshape(3,-1)
#torch.tensor([1,2,3,4,5,6,7,8,9,0]).view(x.size(0),-1)  # 等效于reshape()
print(x.size(1)) #等于x.size()[1]
                 #结果打印的是4
```
结果打印的是4

## 10.contiguous
有些tensor不是一整块内存，而是又不同的数据块组成，而tensor的view()操作依赖于内存是整块的，这时只需要执行以下contiguous()这个操作。
##11..permute(dims)
常用的维度转换方法,类似于numpy()中的transpose():
将tensor的维度换位      参数：dim(int)---换位顺序
```
>>>x = torch.randn(2,3,5)
>>>x.size()
torch.size([2,3,5])
>>>x.permute(2,0,1).size()
torch.size([5,2,3])
```
#~~~其他的一些方法(未验证):
input:输入可以是Tensor向量，也可以输入单个值。output表示返回的结果，返回可以是向量也可以单个值。
torch.lerp(star, end, weight) : 返回结果是out= star t+ (end-start) * weight
torch.rsqrt(input) : 返回平方根的倒数
torch.mean(input) : 返回平均值
torch.std(input) :返回标准偏差
torch.prod(input) : 返回所有元素的乘积
torch.sum(input) : 返回所有元素的之和
torch.var(input) : 返回所有元素的方差
torch.tanh(input)：返回元素双正切的结果

element_size() ：返回单个元素的字节

lee-romantic 's Blog

导航

最近发表

友情链接