Pytorch Pytorch的基本使用 基本使用 张量的简介 1.张量的基本类型 2.张量的创建 1).基本创建方式 1.torch.tensor()根据指定数据创建张量 2.torch.Tensor() 根据指定形状创建张量,也可以用来创建指定数据的张量 3.torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量 2) 创建线性张量和随机张量 1.torch.arange(),torch.linspace()创建线性张量 2.随机种子操作 查看随机种子:torch.inital_seed() 设置随机种子:torch.manual_seed() 创建随机张量:torch.randn() 3).创建0-1张量 1.创建全0张量:torch.zeros 和 torch.zeros_like 2.创建全1张量:torch.ones 和torch.ones_like 3.创建指定值张量:torch.full 和 torch.full_like 4).元素类型转换 1.data.type(torch.DoubleTensor):小数形式 2.data.double() 5).总结 <1> 创建张量的方式 <2> 创建线性数据和随机张量 <3> 创建0-1张量 <4> 元素类型转换:两种方式 3.类型的转换 1).张量转换为numpy数组 使用Tensor.numpy函数将张量转换为ndarray数组,但是共享内存,可以使用copy函数避免共享 2).将numpy数组转换为张量 使用from_numpy可以将ndarray数组转换为Tensor.默认共享内存,使用copy可避免 使用torch.tensor可以将ndarray数组转化为Tensor,默认不共享内存 3).标量张量和数字转换 对于只有一个元素的张量,使用item()函数从张量里面提取出来 4.张量的计算 1).张量的基本运算 加减乘除取负号: 2).张量点乘运算 点乘指的是两个同维矩阵对应位置的元素相乘,使用mul和运算符号实现. 3)张量矩阵乘法运算 行乘以列 矩阵乘法运算要求第一个矩阵shape:(n,m),第二个矩阵shape:(m,p).两个矩阵点积运算为:(n,p) 运算符用@来表示两矩阵的乘积 torch.matmul对进行运算的两个矩阵没有限定对输入的shape不用的张量,对应的最后的几个维度必须符合矩阵运算规则 5.张量的运算函数 均值:mean() 平方根:sqrt() 求和:sum() 指数计算:exp() 对数计算:log() 以e为底,log2() 以2为底 6.张量索引操作 操作张量时,要获取某些元素处理和修改 ,需要了解torch中索引操作 准备数据 1)简单行列索引的使用 2)列表索引范围的使用 3)范围索引的使用 4)布尔值索引的使用 5)多维索引的使用 7.张量的形状操作 深度学习模型都是以某种方式操作张量,由于矩阵乘法的规则,如果形状不同会遇到错误,可使用修改形状 举例说明 1).reshape 函数可以保证张量数据不变的前提下改变数据的维度,并将其转换为指定的形状. 使用torch.reshape()增加一个维度 使用torch.reshape()改变形状 2). view/contiguous view函数也可用于修改张量的结构,只能用于存储在整块内存中的张量 先查看张量是否在一整块内存中:使用is_contiguous 使用contiguous函数转换为整块内存中的张量,在使用函数view函数 3)stack函数堆叠 4).squeeze函数删除形状为1的维度(降维),unsqueeze函数添加形状为1的维度(升维) 5).transpose函数可以实现交换张量形状的指定维度,例如一个张量的形状为(2,3,4),可以通过transpose把3和4交换,形状变为(2,4,3). permute函数可以一次交换更多的维度 6)总结 <1> reshape函数可以在保证数据不变的前提下改变数据的维度 <2> squeeze和unsqueeze函数可以用来增加或减少维度 <3> transpose函数可以实现交换张量形状的指定维度,permute可以一次交换更多的维度 <4> view函数可用于修改张量的形状,但内存必须得连续的一般结合contiguous函数使用
Pytorch的基本使用
基本使用
张量的简介
例如:例如,图像可以表示为形状为 [3, 224, 224]
的张量,这意味着 [colour_channels, height, width]
,因为图像具有 3
颜色通道(红色、绿色、蓝色),高度为 224
像素,宽度为 224
像素。 在张量的语言中,张量将具有三个维度,一个维度表示colour_channels,height和width.
1.张量的基本类型
import torch
scalar = torch. tensor( 8 )
print ( scalar. ndim)
vector = torch. tensor( [ 8 , 8 ] )
print ( vector. ndim)
matrix = torch. tensor( [ [ 8 , 8 ] , [ 9 , 8 ] ] )
print ( matrix. ndim)
tensor = torch. tensor( [ [ [ 1 , 1 ] , [ 2 , 2 ] , [ 3 , 3 ] , [ 4 , 4 ] ] ] )
print ( tensor. ndim)
2.张量的创建
1).基本创建方式
torch. tensor 根据指定数据类型创建张量
torch. Tensor 跟据形状创建张量, , 也可用来创建指定数据的张量
torch. IntTensor, FloatTensor, DoubleTensor创建指定类型张量
1.torch.tensor()根据指定数据创建张量
data = torch. tensor( 10 )
print ( data)
data = np. random. randn( 2 , 3 )
data = torch. tensor( data)
print ( data)
data = torch. tensor( [ [ 10 . , 20 . , 30 . ] , [ 1 . , 2 . , 3 . ] ] )
print ( data)
2.torch.Tensor() 根据指定形状创建张量,也可以用来创建指定数据的张量
data = torch. Tensor( 2 , 3 )
print ( data)
data = torch. Tensor( [ 10 ] )
print ( data)
3.torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量
data = torch. IntTensor( 2 , 3 )
print ( data)
>> > tensor( [ [ 0 , 1610612736 , 1213662609 ] , [ 805308409 , 156041223 , 1 ] ] , dtype= torch. int32)
data = torch. IntTensor( [ 2.5 , 3.3 ] )
print ( data)
>> > tensor( [ 2 , 3 ] , dtype= torch. int32)
data = torch. ShortTensor( )
data = torch. LongTensor( )
data = torch. FloatTensor( )
data = torch. DoubleTensor( )
2) 创建线性张量和随机张量
1.torch.arange(),torch.linspace()创建线性张量
data = torch. arange( 0 , 10 , 2 )
print ( data)
data = torch. linspace( 0 , 11 , 10 )
print ( data)
2.随机种子操作 设置随机种子:torch.manual_seed()
data3 = torch. randn( 2 , 3 )
print ( data3)
print ( '随机数种子为:' , torch. random. initial_seed( ) )
torch. random. manual_seed( 21 )
data4 = torch. randn( 2 , 3 )
print ( data4)
print ( '随机数种子为' , torch. random. initial_seed( ) )
3).创建0-1张量
1.创建全0张量:torch.zeros 和 torch.zeros_like
data5 = torch. zeros( 2 , 3 )
print ( data5)
data6 = torch. zeros_like( data5)
print ( data6)
2.创建全1张量:torch.ones 和torch.ones_like
data7 = torch. ones( 3 , 5 )
print ( data7)
data8 = torch. ones_like( data7)
print ( data8)
3.创建指定值张量:torch.full 和 torch.full_like
data9 = torch. full( [ 2 , 3 ] , 8 )
print ( data9)
data10 = torch. full_like( data9, 1 )
print ( data10)
4).元素类型转换
1.data.type(torch.DoubleTensor):小数形式 data = torch. full( [ 2 , 3 ] , 10 )
print ( data. dtype)
data = data. type ( torch. DoubleTensor)
print ( data. dtype)
2.data.double()
data = data. double( )
print ( data. dtype)
5).总结
torch. tensor根据数据创建torch. Tensor根据形状创建, 也可用来创建指定数据的张量torch. IntTensor( ) , torch. FloatTensor( ) , torch. DoubleTensor( ) 创建指定类型的张量
torch. arange指定步长和torch. linspsce( ) 指定数量: 线性张量
查看随机种子: torch. random. initial_seed( )
设置随机种子: torch. random. manual_seed( )
torch. randn( ) 创建随机张量
torch. zreos( ) 和 troch. zeros_like( ) 创建全0 的张量
torch. ones( ) 和 torch. ones_like( ) 创建全1 的张量
torch. full 和 torch. full_like( ) 创建全为指定值的张量
data. type ( torch. DoubleTensor)
data. double( )
3.类型的转换
1).张量转换为numpy数组
使用Tensor.numpy函数将张量转换为ndarray数组,但是共享内存,可以使用copy函数避免共享
data_tensor = torch. tensor( [ 2 , 3 , 4 ] )
data_numpy = data_tensor. numpy( )
print ( type ( data_tensor) )
print ( type ( data_numpy) )
data_numpy[ 1 ] = 100
print ( data_tensor)
print ( data_numpy)
data_tensor = torch. tensor( [ 2 , 3 , 4 ] )
data_numpy = data_tensor. numpy( ) . copy( )
data_numpy[ 1 ] = 100
print ( data_tensor)
print ( data_numpy)
2).将numpy数组转换为张量
使用from_numpy可以将ndarray数组转换为Tensor.默认共享内存,使用copy可避免
data_numpy = np. array( [ 2 , 3 , 4 ] )
data_tensor = torch. from_numpy( data_numpy. copy( ) )
data_tensor[ 1 ] = 100
print ( data_numpy)
print ( data_tensor)
使用torch.tensor可以将ndarray数组转化为Tensor,默认不共享内存
data_numpy = np. array( [ 2 , 3 , 4 ] )
data_tensor = torch. tensor( data_numpy)
data_tensor[ 1 ] = 100
print ( data_numpy)
print ( data_tensor)
3).标量张量和数字转换
对于只有一个元素的张量,使用item()函数从张量里面提取出来
data = torch. tensor( [ 20 , ] )
print ( data)
print ( data. item( ) ) data = torch. tensor( 30 )
print ( data. item( ) )
4.张量的计算
1).张量的基本运算
add, sub, mul, div, neg
add_, sub_, mul_, div_, neg_带下划线会修改原始数据
torch. random. manual_seed( 21 )
data = torch. randint( 0 , 10 , [ 2 , 3 ] )
print ( data)
new_data = data. add( 10 )
print ( new_data)
data. add_( 10 )
print ( data)
data_sub = data. sub( 100 )
print ( data_sub)
data_mul = data. mul( 10 )
print ( data_mul)
data_div = data. div( 100 )
print ( data_div)
data_neg = data. neg( )
print ( data_neg)
2).张量点乘运算
点乘指的是两个同维矩阵对应位置的元素相乘,使用mul和运算符号实现.
data1 = torch. tensor( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
data2 = torch. tensor( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
data3 = torch. mul( data1, data2)
print ( data1)
print ( data2)
print ( data3)
3)张量矩阵乘法运算
data1 = torch. tensor( [ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ] )
data2 = torch. tensor( [ [ 7 , 8 ] , [ 9 , 10 ] ] )
data3 = data1 @ data2
print ( data1)
print ( data2)
print ( data3)
data3 = torch. matmul( data1, data2)
print ( data3)
5.张量的运算函数
均值:mean() 求和:sum() 对数计算:log() 以e为底,log2() 以2为底
torch. random. manual_seed( 21 )
data = torch. randint( 0 , 10 , [ 3 , 4 ] , dtype= torch. float64)
print ( data)
print ( data. mean( ) )
print ( data. mean( dim= 0 ) )
print ( data. mean( dim= 1 ) )
print ( data. sum ( ) )
print ( data. sum ( dim= 0 ) )
print ( data. sum ( dim= 1 ) )
print ( torch. pow ( data, 2 ) )
print ( data. sqrt( ) )
print ( data. exp( ) )
print ( data. log( ) )
print ( data. log2( ) )
print ( data. log10( ) )
6.张量索引操作
操作张量时,要获取某些元素处理和修改 ,需要了解torch中索引操作
准备数据
import torch
torch. random. manual_seed( 21 )
data = torch. randint( 0 , 10 , [ 5 , 5 ] )
print ( data)
1)简单行列索引的使用
print ( data[ 0 ] )
print ( data[ : , 0 ] )
2)列表索引范围的使用
print ( data[ [ 1 , 3 ] , [ 1 , 3 ] ] )
print ( data[ [ [ 0 ] , [ 1 ] ] , [ 1 , 2 ] ] )
3)范围索引的使用
print ( data[ : 3 , : 2 ] )
print ( data[ 2 : , : 2 ] )
print ( data[ 0 : 3 : 2 , : 2 ] )
4)布尔值索引的使用
print ( data[ data[ : , 2 ] > 5 ] )
print ( data[ : , data[ 1 ] > 5 ] )
5)多维索引的使用
torch. random. manual_seed( 21 )
data = torch. randint( 0 , 10 , [ 3 , 4 , 5 ] )
print ( data)
print ( data[ 0 , 0 , : ] )
print ( data[ 1 , 0 , : ] )
print ( data[ 2 , 0 , : ] )
print ( data[ 1 , 1 : 3 , 2 : 4 ] )
print ( data[ 2 , 0 : 4 : 3 , 0 : 4 : 3 ] )
7.张量的形状操作
深度学习模型都是以某种方式操作张量,由于矩阵乘法的规则,如果形状不同会遇到错误,可使用修改形状
举例说明
import torchx = torch. arange( 1 . , 8 . )
print ( x)
print ( x. shape)
print ( x. size( ) )
1).reshape 函数可以保证张量数据不变的前提下改变数据的维度,并将其转换为指定的形状.
import torchx = torch. arange( 1 . , 8 . )
print ( x)
print ( x. shape)
print ( x. size( ) )
x_reshape = x. reshape( 1 , 7 )
print ( x_reshape)
print ( x_reshape. shape)
data = torch. tensor( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
print ( data. shape, data. shape[ 0 ] , data. shape[ 1 ] )
print ( data. size( ) , data. size( 0 ) , data. size( 1 ) )
new_data = data. reshape( 1 , - 1 )
print ( new_data)
2). view/contiguous
view函数也可用于修改张量的结构,只能用于存储在整块内存中的张量 使用contiguous函数转换为整块内存中的张量,在使用函数view函数
data = torch. tensor( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
print ( data, data. shape)
print ( data. is_contiguous( ) )
data1 = data. view( 3 , - 1 )
print ( data1)
print ( data1. is_contiguous( ) )
data3 = torch. transpose( data, 0 , 1 )
print ( data3, data3. shape)
print ( data3. is_contiguous( ) )
data4 = data3. contiguous( ) . view( 2 , - 1 )
print ( data4)
3)stack函数堆叠
data1 = torch. stack( [ data, data, data] , dim= 0 )
print ( data)
print ( data1)
4).squeeze函数删除形状为1的维度(降维),unsqueeze函数添加形状为1的维度(升维)
data1 = torch. tensor( [ [ 1 , 2 , 3 , 4 , 5 ] ] )
print ( data1. shape)
data2 = data1. unsqueeze( dim= 0 )
print ( data2)
data3 = data1. unsqueeze( dim= 1 )
print ( data3)
data4 = data1. unsqueeze( dim= - 1 )
print ( data4)
data5 = data1. unsqueeze( dim= 2 )
print ( data5)
data6 = data1. squeeze( )
print ( data6)
data7 = data1. squeeze( dim= 0 )
print ( data7)
5).transpose函数可以实现交换张量形状的指定维度,例如一个张量的形状为(2,3,4),可以通过transpose把3和4交换,形状变为(2,4,3). permute函数可以一次交换更多的维度
torch. random. manual_seed( 21 )
data1 = torch. tensor( np. random. randint( 0 , 10 , [ 3 , 4 , 5 ] ) )
data2 = torch. randint( 0 , 10 , [ 3 , 4 , 5 ] )
print ( data1. shape)
print ( data2. shape)
data3 = torch. transpose( data1, 1 , 2 )
print ( data3. shape)
data4 = torch. transpose( data1, 0 , 1 )
print ( data4. shape)
data5 = torch. transpose( data4, 1 , 2 )
print ( data5. shape)
data6 = torch. permute( data1, [ 1 , 2 , 0 ] )
print ( data6. shape)
data7 = data1. permute( [ 1 , 2 , 0 ] )
print ( data7. shape)
print ( data7)
6)总结
<1> reshape函数可以在保证数据不变的前提下改变数据的维度 <3> transpose函数可以实现交换张量形状的指定维度,permute可以一次交换更多的维度