numpy与tensor基础

numpy

基础

#numpy
import numpy as np
'''numpy定义'''
a=np.array([2,3,4]) #创造秩为1，内容为2,3,4的数组
b=np.array([(2,3,4), (4,5,6)]) #创造秩为2的数组，也就是二维数组
c=np.array([[2,3,4], [4,5,6]]) #同上，只是写法不一样
d=np.array([[2,3,4], [4,5,6]],dtype=complex) #显式指明数据类型
e=np.zeros((3,4))#创造一个3行4列的矩阵，并初始化为0，数据类型默认为float64，可自定义：dtype=np.int32
f=np.ones((3,4))#创造一个3行4列的矩阵，并初始化为1
g=np.empty((3,4))#创造一个3行4列的矩阵，未初始化，为随机值
h=np.arange(5)#定义从0开始，步长为1的秩为1的5个数的数组
i=np.arange(10,30,5)#定义从起始值（参数一），到结束值（参数二），以步长（参数三）为间隔的秩为1的数组
j=np.linspace(0,2,9)#定义从0到2（包括两者）间的秩为1的9个数的数组
'''numpy计算'''
k=e-f#减法计算，按位相减
l=h**2#平方运算，按位求平方
n=np.sin(l)#三角函数运算，按位求三角函数
m=h<3#比较逻辑运算，按位比较，满足为真，不满足为假
o=b*c#乘法运算，按位相乘
p=np.transpose(c)#矩阵转置
q=b.dot(p)#矩阵相乘
r=h.sum()#数组全体数求和
s=h.min()#取数组中的最小值
t=h.max()#取数组中的最大值
'''numpy索引'''
u=np.arange(10)**3
print(u[2])#索引数组的第二项
print(u[2:5])#索引数组第二到五项
u[0:6:2]=-100#从开始位置到索引为6的元素为止，每隔一个元素将其赋值为-100(第一个参数可以不写，则默认为0)
v=u[::-1]#反转u
'''遍历数组'''
for i in u:
    print(i)
'''用函数创建数组'''
def f(x,y):
    return 10*x+y
w=np.fromfunction(f,(5,4),dtype=int)
print(w[2,3])#二维数组数值索引
print(w[0:5,1])#二维数组0~4行第二个元素索引
print(w[:,1])#二维数组每行第二个元素索引
print(w[1:3,:])#二维数组第2到3行索引
print(w[-1])#二维数组最后一行索引，等价于print(w[-1,:])
print(d.dtype)#获得数据类型

提高（神经网络向）

import numpy as np

a=np.array([[2,3,4],[2,3,4]])
b=np.array([[1,3,4],[1,3,4]])
'''对位比较元素值的大小，相同返回True不同返回False'''
c=(a==b)
'''获得相同的元素个数'''
c=(a==b).sum()
'''色彩转换'''
#颜色表
VOC_COLORMAP = [[0, 0, 0], [128, 0, 0], [0, 128, 0], [128, 128, 0],
                [0, 0, 128], [128, 0, 128], [0, 128, 128], [128, 128, 128],
                [64, 0, 0], [192, 0, 0], [64, 128, 0], [192, 128, 0],
                [64, 0, 128], [192, 0, 128], [64, 128, 128], [192, 128, 128],
                [0, 64, 0], [128, 64, 0], [0, 192, 0], [128, 192, 0],
                [0, 64, 128]]
#假设有颜色表，当前数据为其索引，希望得到索引对应的颜色
d=np.array([2,3,4])
e=np.array(VOC_COLORMAP)[d]
#假设有颜色表，当前数据为颜色，希望得到对应的索引
colormap2label = np.zeros(256**3)
#整个循环的意思就是将颜色标签映射为单通道的数组索引
for i, cm in enumerate(VOC_COLORMAP):
    colormap2label[(cm[2] * 256 + cm[1]) * 256 + cm[0]] = i
color = np.array([[[0, 0, 0], [128, 0, 0], [0, 128, 0]],[[0, 0, 0], [128, 0, 0], [0, 128, 0]]])
idx = ((color[:, :, 2] * 256 + color[ :, :,1]) * 256+ color[:, :,0])#获得颜色对应单通道数值索引
out = colormap2label[idx]#获得颜色表格索引值
'''数据类型转换'''
out = out.astype(np.int64)
'''维度交换'''
print(out.shape)#2乘3
out = np.transpose(out, [1,0]) #交换第0维和第1维的位置，其他维度的交换也类似[0,2,1]则是交换第1维和第2维的位置
print(out.shape)#3乘2

tensor

基础

#pytorch张量
import torch
'''张量定义'''
a=torch.FloatTensor(2,3)#定义一个两行三列的张量
b=torch.FloatTensor([2,3,4,5])#定义一个四行一列的张量，并给每个数字赋值
c=torch.rand(2,3)#定义一个两行三列的张量，并以0~1之间的随机数填充
d=torch.randn(2,3)#定义一个两行三列的张量，并以均值为0，且方差为1的正态分布随机数填充
e=torch.arange(1,20,1)#定义从起始值（参数一），到结束值（参数二），以步长（参数三）为间隔的单列多行张量
f=torch.zeros(2,3)#定义一个两行三列的张量,初始化为0，效果同a
'''张量计算'''
g=torch.abs(d)#返回张量绝对值
g=torch.add(g,d)#两同维度张量值对应相加
g=torch.add(g,10)#张量值全部加10
#另外div为除法，mul为乘法，用法皆同加法
g=torch.clamp(g,-0.1,0.1)#张量裁剪，第二个参数和第三个参数分别为上下边界
g=torch.pow(g,2)#求幂，第二个参数为幂数
'''矩阵乘法'''
a=torch.randn(2,3)
b=torch.randn(3,2)
c=torch.mm(a,b)

提高（神经网络向）

import torch
'''numpy转tensor'''
color = np.array([[[0, 0, 0], [128, 0, 0], [0, 128, 0]],[[0, 0, 0], [128, 0, 0], [0, 128, 0]]])
b = torch.from_numpy(color)
'''将矩阵展开成一维'''
target = b.contiguous() .view(-1)
'''将矩阵展前面的维度展开，保持最后一维'''
target = b.contiguous() .view(-1,3)
'''维度转换'''
outlabimg = b.transpose(0, 1)#第0维和第1维互换
'''相同数值统计'''
a=torch.FloatTensor([[[2,3,0,5],[2,3,0,5]],[[2,3,0,5],[2,3,0,5]]])
b=torch.FloatTensor([[[2,3,4,5],[2,3,0,5]],[[2,3,0,5],[2,3,0,5]]])
equl=(a==b).sum()
print(a.shape)
print(equl)