pytroch中最清晰明白的dim 张量 维数讲解

Pytorch 中的 dim

Pytorch 中对 tensor 的很多操作如 sumargmaxunsqueeze 等都可以设置 dim 参数用来指定操作在哪一维进行。Pytorch 中的 dim 类似于 numpy 中的 axis,这篇文章来总结一下 Pytorch 中的 dim 操作。

dim 与方括号的关系#

创建一个矩阵

 
a = torch.tensor([[1, 2], [3, 4]]) print(a)

输出

 

tensor([[1, 2], [3, 4]])

因为a是一个矩阵,所以a的左边有 2 个括号

括号之间是嵌套关系,代表了不同的维度。从左往右数,两个括号代表的维度分别是 0 和 1 ,在第 0 维遍历得到向量,在第 1 维遍历得到标量

同样地,对于 3 维 tensor

b = torch.tensor([[[3, 2], [1, 4]], [[5, 6], [7, 8]]]) print(b)

输出

 

tensor([[[3, 2], [1, 4]], [[5, 6], [7, 8]]])

则 3 个括号代表的维度从左往右分别为 0, 1, 2,在第 0 维遍历得到矩阵,在第 1 维遍历得到向量,在第 2 维遍历得到标量

更详细一点

在指定的维度上进行操作#

在某一维度求和(或者进行其他操作)就是对该维度中的元素进行求和。
对于矩阵 a

 
a = torch.tensor([[1, 2], [3, 4]]) print(a)

输出

 
tensor([[1, 2], [3, 4]])

求 a 在第 0 维的和,因为第 0 维代表最外边的括号,括号中的元素为向量[1, 2][3, 4],第 0 维的和就是第 0 维中的元素相加,也就是两个向量[1, 2][3, 4]相加,所以结果为

[1,2]+[3,4]=[4,6][1,2]+[3,4]=[4,6]

s = torch.sum(a, dim=0) print(s)
 

输出

 

Copy

tensor([4, 6])

可以看到,a 是 2 维矩阵,而相加的结果为 1 维向量,可以使用参数keepdim=True来保证形状不变

 

Copy

s = torch.sum(a, dim=0, keepdim=True) print(s)

输出

 

Copy

tensor([[4, 6]])

在 a 的第 0 维求和,就是对第 0 维中的元素(向量)进行相加。同样的,对 a 第 1 维求和,就是对 a 第 1 维中的元素(标量)进行相加,a 的第 1 维元素为标量 1,2 和 3,4,则结果为

[1+2]=[3], [3+4]=[7][1+2]=[3], [3+4]=[7]

 

Copy

s = torch.sum(a, dim=1) print(s)

输出

 

Copy

tensor([3, 7])

保持维度不变

 

Copy

s = torch.sum(a, dim=1, keepdim=True) print(s)

输出

 

Copy

tensor([[3], [7]])

对 3 维 tensor 的操作也是这样

 

Copy

b = torch.tensor([[[3, 2], [1, 4]], [[5, 6], [7, 8]]]) print(b)

输出

 

Copy

tensor([[[3, 2], [1, 4]], [[5, 6], [7, 8]]])

将 b 在第 0 维相加,第 0 维为最外层括号,最外层括号中的元素为矩阵[[3, 2], [1, 4]][[5, 6], [7, 8]]。在第 0 维求和,就是将第 0 维中的元素(矩阵)相加

[3124]+[5768]=[88812][3214]+[5678]=[88812]

 

Copy

s = torch.sum(b, dim=0) print(s)

输出

 

Copy

tensor([[ 8, 8], [ 8, 12]])

求 b 在第 1 维的和,就是将 b 第 1 维中的元素[3, 2][1, 4], [5, 6][7, 8]相加,所以

[3,2]+[1,4]=[4,6],[5,6]+[7,8]=[12,14][3,2]+[1,4]=[4,6],[5,6]+[7,8]=[12,14]

 

Copy

s = torch.sum(b, dim=1) print(s)

输出

 

Copy

tensor([[ 4, 6], [12, 14]])

则在 b 的第 2 维求和,就是对标量 3 和 2, 1 和 4, 5 和 6 , 7 和 8 求和

 

Copy

s = torch.sum(b, dim=2) print(s)

结果为

 

Copy

tensor([[ 5, 5], [11, 15]])

除了求和,其他操作也是类似的,如求 b 在指定维度上的最大值

 

Copy

m = torch.max(b, dim=0) print(m)

b 在第 0 维的最大值是第 0 维中的元素(两个矩阵[[3, 2], [1, 4]][[5, 6], [7, 8]])的最大值,取矩阵对应位置最大值即可
结果为

 

Copy

torch.return_types.max( values=tensor([[5, 6], [7, 8]]), indices=tensor([[1, 1], [1, 1]]))

b 在第 1 维的最大值就是第 1 维元素(4 个(2对)向量)的最大值

 

Copy

m = torch.max(b, dim=1) print(m)

输出为

 

Copy

torch.return_types.max( values=tensor([[3, 4], [7, 8]]), indices=tensor([[0, 1], [1, 1]]))

b 在第 0 维的最大值就是第 0 为元素(8 个(4 对)标量)的最大值

 

Copy

m = torch.max(b, dim=2) print(m)

输出

 

Copy

torch.return_types.max( values=tensor([[3, 4], [6, 8]]), indices=tensor([[0, 1], [1, 1]]))

总结#

在 tensor 的指定维度操作就是对指定维度包含的元素进行操作,如果想要保持结果的维度不变,设置参数keepdim=True即可。

作者: Flix 

出处:https://www.cnblogs.com/flix/p/11262606.html

本站使用「CC BY 4.0」创作共享协议,转载请在文章明显位置注明作者及出处。

PyTorch中的LSTM模型是一种递归神经网络,常用于处理序列据,例如文本、音频和视频。在本篇文章中,我们将深入了解PyTorch中LSTM模型的各种参,并提供实例进行讲解。 ### LSTM模型参 PyTorch中LSTM模型的主要参如下: - **input_size**:输入据的特征度。 - **hidden_size**:LSTM层中隐藏状态的度。 - **num_layers**:LSTM层。 - **bias**:是否使用偏置。 - **batch_first**:如果为True,则输入和输出张量的形状将是(batch_size, seq_length, feature_dim)。 - **dropout**:设置dropout概率。 - **bidirectional**:如果为True,则使用双向LSTM。 ### LSTM模型实例 下面我们将通过一个实例来详细讲解LSTM模型参的使用。 首先,我们需要导入所需的库和据集。在这里,我们将使用PyTorch中内置的IMDB电影评论据集。 ```python import torch import torch.nn as nn import torch.optim as optim from torchtext.datasets import IMDB from torchtext.data import Field, LabelField, BucketIterator # 定义字段 text = Field(tokenize='spacy', tokenizer_language='en_core_web_sm') label = LabelField(dtype=torch.float) # 加载据集 train_data, test_data = IMDB.splits(text, label) # 构建词汇表 text.build_vocab(train_data, max_size=10000, vectors="glove.6B.100d") label.build_vocab(train_data) # 创建iterators batch_size = 64 train_iterator, test_iterator = BucketIterator.splits( (train_data, test_data), batch_size=batch_size, device=torch.device('cuda')) ``` 接下来,我们将定义LSTM模型。在这里,我们将使用单层LSTM和batch_first=True。 ```python class LSTMModel(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super().__init__() self.hidden_dim = hidden_dim self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): h0 = torch.zeros(1, x.size(0), self.hidden_dim).to(device) c0 = torch.zeros(1, x.size(0), self.hidden_dim).to(device) out, (hn, cn) = self.lstm(x, (h0, c0)) out = self.fc(out[:, -1, :]) return out ``` 在这里,我们将输入度指定为100,隐藏状态度指定为128,输出度指定为1。我们还指定了初始隐藏状态和记忆单元。 接下来,我们将定义优化器和损失函: ```python device = torch.device('cuda') model = LSTMModel(input_dim=100, hidden_dim=128, output_dim=1).to(device) optimizer = optim.Adam(model.parameters(), lr=1e-3) criterion = nn.BCEWithLogitsLoss().to(device) ``` 在这里,我们使用Adam优化器和二元交叉熵损失函后,我们将训练模型: ```python def train(model, iterator, optimizer, criterion): epoch_loss = 0 epoch_acc = 0 model.train() for batch in iterator: optimizer.zero_grad() text, text_lengths = batch.text predictions = model(text).squeeze(1) loss = criterion(predictions, batch.label) acc = binary_accuracy(predictions, batch.label) loss.backward() optimizer.step() epoch_loss += loss.item() epoch_acc += acc.item() return epoch_loss / len(iterator), epoch_acc / len(iterator) def evaluate(model, iterator, criterion): epoch_loss = 0 epoch_acc = 0 model.eval() with torch.no_grad(): for batch in iterator: text, text_lengths = batch.text predictions = model(text).squeeze(1) loss = criterion(predictions, batch.label) acc = binary_accuracy(predictions, batch.label) epoch_loss += loss.item() epoch_acc += acc.item() return epoch_loss / len(iterator), epoch_acc / len(iterator) def binary_accuracy(preds, y): rounded_preds = torch.round(torch.sigmoid(preds)) correct = (rounded_preds == y).float() acc = correct.sum() / len(correct) return acc N_EPOCHS = 5 for epoch in range(N_EPOCHS): train_loss, train_acc = train(model, train_iterator, optimizer, criterion) valid_loss, valid_acc = evaluate(model, test_iterator, criterion) print(f'Epoch: {epoch+1:02}') print(f'\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%') print(f'\t Val. Loss: {valid_loss:.3f} | Val. Acc: {valid_acc*100:.2f}%') ``` 在这里,我们训练了5个epoch,并计算了训练和测试集上的损失和准确率。 ### 总结 在本篇文章中,我们深入了解了PyTorch中LSTM模型的各种参,并通过一个实例进行了讲解
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值