torch.split(tensor, split_size, dim=0)

最新推荐文章于 2024-07-02 20:35:08 发布
最新推荐文章于 2024-07-02 20:35:08 发布
阅读量1k 收藏 1
点赞数
分类专栏： Python
原文链接：https://blog.csdn.net/gyt15663668337/article/details/91345951
版权

torch.split(tensor, split_size, dim=0)

说明：将输入张量分割成相等形状的chunks(如果可分)。如果沿指定维的张量形状大小不能被整分，则最后一块会小于其他分块。

参数：

tensor(Tensor) -- 待分割张量
split_size(int) -- 单个分块的形状大小
dim(int) -- 沿着此维进行分

>>> x = torch.randn(3, 4)
>>> x
tensor([[ 0.1135,  0.5779, -0.9737, -0.0718],
        [ 0.4136,  1.1577,  0.5689, -0.1970],
        [ 1.4281,  0.3540,  1.4346, -0.1444]])
>>> torch.split(x, 2, 1)
(tensor([[0.1135, 0.5779],
        [0.4136, 1.1577],
        [1.4281, 0.3540]]), tensor([[-0.9737, -0.0718],
        [ 0.5689, -0.1970],
        [ 1.4346, -0.1444]]))
>>> torch.split(x, 2, 0)
(tensor([[ 0.1135,  0.5779, -0.9737, -0.0718],
        [ 0.4136,  1.1577,  0.5689, -0.1970]]), tensor([[ 1.4281,  0.3540,  1.4346, -0.1444]]))


原文链接：https://blog.csdn.net/gyt15663668337/article/details/91345951

 

 

NDHuaErFeiFei
关注
专栏目录
Pytorch框架之split划分张量
笔岸柳影
10-31 1088
pytorch的split->张量划分
torch.split()与tensor.split()
biubiu713的博客
04-27 392
等价于torch.split(tensor, int/list, dim)将tensor切分为块，每个块都是原始tensor的一个视图。
Pytorch学习之torch.split函数
最新发布
qq_46396470的博客
07-02 561
用于将一个张量（tensor）沿指定维度（dim）拆分为多个子张量。这个函数对于处理需要按块拆分数据的任务非常有用，例如在自然语言处理和图像处理中的数据预处理。
Pytorch-tensor的分割，属性统计
gy77
10-07 1936
1.矩阵的分割 方法：split(分割长度,所分割的维度)，split([分割所占的百分比],所分割的维度) a=torch.rand(32,8) aa,bb=a.split(16,dim=0) print(aa.shape) print(bb.shape) cc,dd=a.split([20,12],dim=0) print(cc.shape) print(dd.shape) 输出...
pytorch: tensor的拆分和拼接（split, chunk, cat, stack）
傲笑风的博客
11-19 7236
tensor的拆分和拼接（split, chunk, cat, stack）
import torch import torch.nn as nn from torchtext.datasets import AG_NEWS from torchtext.data.utils import get_tokenizer from torchtext.vocab import build_vocab_from_iterator # 数据预处理 tokenizer = get_tokenizer('basic_english') train_iter = AG_NEWS(split='train') counter = Counter() for (label, line) in train_iter: counter.update(tokenizer(line)) vocab = build_vocab_from_iterator([counter], specials=["<unk>"]) word2idx = dict(vocab.stoi) # 设定超参数 embedding_dim = 64 hidden_dim = 128 num_epochs = 10 batch_size = 64 # 定义模型 class RNN(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim): super(RNN, self).__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.rnn = nn.RNN(embedding_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, 4) def forward(self, x): x = self.embedding(x) out, _ = self.rnn(x) out = self.fc(out[:, -1, :]) return out # 初始化模型、优化器和损失函数 model = RNN(len(vocab), embedding_dim, hidden_dim) optimizer = torch.optim.Adam(model.parameters()) criterion = nn.CrossEntropyLoss() # 定义数据加载器 train_iter = AG_NEWS(split='train') train_data = [] for (label, line) in train_iter: label = torch.tensor([int(label)-1]) line = torch.tensor([word2idx[word] for word in tokenizer(line)]) train_data.append((line, label)) train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=True) # 开始训练 for epoch in range(num_epochs): total_loss = 0.0 for input, target in train_loader: model.zero_grad() output = model(input) loss = criterion(output, target.squeeze()) loss.backward() optimizer.step() total_loss += loss.item() * input.size(0) print("Epoch: {}, Loss: {:.4f}".format(epoch+1, total_loss/len(train_data)))改错
05-25
train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=True) # 开始训练 for epoch in range(num_epochs): total_loss = 0.0 for input, target in train_loader: optimizer...
class Partial_conv3(nn.Module): def __init__(self, dim, n_div, forward): super().__init__() self.dim_conv3 = dim // n_div self.dim_untouched = dim - self.dim_conv3 self.partial_conv3 = nn.Conv2d(self.dim_conv3, self.dim_conv3, 3, 1, 1, bias=False) if forward == 'slicing': self.forward = self.forward_slicing elif forward == 'split_cat': self.forward = self.forward_split_cat else: raise NotImplementedError def forward_slicing(self, x: Tensor) -> Tensor: # only for inference x = x.clone() # !!! Keep the original input intact for the residual connection later x[:, :self.dim_conv3, :, :] = self.partial_conv3(x[:, :self.dim_conv3, :, :]) return x def forward_split_cat(self, x: Tensor) -> Tensor: x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1) x1 = self.partial_conv3(x1) x = torch.cat((x1, x2), 1) return x 在这段代码中插入全局平均池化做通道增强的模块
06-10
x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1) x1 = self.partial_conv3(x1) x1 = self.global_avg_pool(x1) # 添加全局平均池化 x = torch.cat((x1, x2), 1) return x ```
class Partial_conv3(nn.Module): def __init__(self, dim, n_div, forward): super().__init__() self.dim_conv3 = dim // n_div self.dim_untouched = dim - self.dim_conv3 self.partial_conv3 = nn.Conv2d(self.dim_conv3, self.dim_conv3, 3, 1, 1, bias=False) self.global_pool = GlobalAvgPool2d() if forward == 'slicing': self.forward = self.forward_slicing elif forward == 'split_cat': self.forward = self.forward_split_cat else: raise NotImplementedError def forward_slicing(self, x: Tensor) -> Tensor: # only for inference x = x.clone() # !!! Keep the original input intact for the residual connection later x[:, :self.dim_conv3, :, :] = self.partial_conv3(x[:, :self.dim_conv3, :, :]) return x def forward_split_cat(self, x: Tensor) -> Tensor: x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1) x1 = self.partial_conv3(x1) x1 = self.global_pool(x1) x = torch.cat((x1, x2), 1) return x在这段代码中插入全局平均池化做通道增强的模块
06-10
nn.Conv2d(dim, dim, kernel_size=1, stride=1, padding=0, bias=False), nn.BatchNorm2d(dim), nn.ReLU(inplace=True), self.global_pool ) if forward == 'slicing': self.forward = self.forward_slicing ...
import torchimport torch.nn as nnclass MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super(MultiHeadAttention, self).__init__() self.num_heads = num_heads self.d_model = d_model assert d_model % self.num_heads == 0 self.depth = d_model // self.num_heads self.Wq = nn.Linear(d_model, d_model) self.Wk = nn.Linear(d_model, d_model) self.Wv = nn.Linear(d_model, d_model) self.fc = nn.Linear(d_model, d_model) def scaled_dot_product_attention(self, Q, K, V, mask=None): d_k = Q.size(-1) scores = torch.matmul(Q, K.transpose(-1, -2)) / torch.sqrt(torch.tensor(d_k, dtype=torch.float32)) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) attention = torch.softmax(scores, dim=-1) output = torch.matmul(attention, V) return output, attention def split_heads(self, x, batch_size): x = x.view(batch_size, -1, self.num_heads, self.depth) return x.permute(0, 2, 1, 3) def forward(self, Q, K, V, mask=None): batch_size = Q.size(0) Q = self.Wq(Q) K = self.Wk(K) V = self.Wv(V) Q = self.split_heads(Q, batch_size) K = self.split_heads(K, batch_size) V = self.split_heads(V, batch_size) scaled_attention, attention = self.scaled_dot_product_attention(Q, K, V, mask) scaled_attention = scaled_attention.permute(0, 2, 1, 3).contiguous() scaled_attention = scaled_attention.view(batch_size, -1, self.d_model) output = self.fc(scaled_attention) return output, attention
06-08
- mask：一个shape为[batch_size, 1, seq_length, seq_length]的张量，用于掩盖无效的位置，使得在计算注意力矩阵时，注意力矩阵中无效位置对应的权重为0。如果没有无效位置，则可以设置为None。
def __getitem__(self, index): if self.split=='train': vis_path = self.filepath_vis[index] ir_path = self.filepath_ir[index] label_path = self.filepath_label[index] image_vis = np.array(Image.open(vis_path)) image_inf = cv2.imread(ir_path, 0) label = np.array(Image.open(label_path)) image_vis = ( np.asarray(Image.fromarray(image_vis), dtype=np.float32).transpose( (2, 0, 1) ) / 255.0 ) image_ir = np.asarray(Image.fromarray(image_inf), dtype=np.float32) / 255.0 image_ir = np.expand_dims(image_ir, axis=0) label = np.asarray(Image.fromarray(label), dtype=np.int64) name = self.filenames_vis[index] return ( torch.tensor(image_vis), torch.tensor(image_ir), torch.tensor(label), name, ) elif self.split=='val': vis_path = self.filepath_vis[index] ir_path = self.filepath_ir[index] image_vis = np.array(Image.open(vis_path)) image_inf = cv2.imread(ir_path, 0) image_vis = ( np.asarray(Image.fromarray(image_vis), dtype=np.float32).transpose( (2, 0, 1) ) / 255.0 ) image_ir = np.asarray(Image.fromarray(image_inf), dtype=np.float32) / 255.0 image_ir = np.expand_dims(image_ir, axis=0) name = self.filenames_vis[index] return ( torch.tensor(image_vis), torch.tensor(image_ir), name, )
07-17
将红外图像转为numpy数组，并除以255.0进行归一化，再使用np.expand_dims函数在通道维度上添加一个维度。最后，将标签图像转为numpy数组，并将数据类型设置为int64。 如果是验证集，只获取可见光图像路径（vis_path...
【PyTorch】张量 (Tensor) 的拆分与拼接 (split, chunk, cat, stack)
热门推荐
Panonsense
04-24 2万+
在 PyTorch 中，对张量 (Tensor) 进行拆分通常会用到两个函数： - torch.split [按块大小拆分张量] - torch.chunk [按块数拆分张量] 而对张量 (Tensor) 进行拼接通常会用到另外两个函数： - torch.cat [按已有维度拼接张量] - torch.stack [按新维度拼接张量] 它们的作用相似，但实际效果并不完全相同，以下会通过官方文档及实例代码来进行说明，以示区别
HBase SplitSize 到底是多少
系统运维
11-23 204
大家都知道HBase的一个重要特性就是split，split通常情况下是自动执行的，而trigger条件就是region的size到达一定大小。那么到底这个大小是多少纳？ 笔者google了一些文章，不少文章说是256M，但也有一些说是1G。那么到底是多少纳? HBase是支持设置Table级别的splitsize的，HTableDescriptor类里读取FileSize的代码如下：...
Tensor的切片
huihuixiaoxue的博客
01-05 2895
chunk split 注意 chunk第二个参数表示 分成几块；split第二个参数表示 分成多大的块。 chunk分块时，每块的平均数会向上取整，如本例：4/3向上取整，每个0维度上，分2个元素，所以才会出现传参数3，要求分成3块，最后却只分成2块。 ...
torch.split()函数用法讲解[含代码实例]
Alan_sunshine的博客
06-23 940
# torch.split(tensor, split_size, dim)函数对张量tensor在指定维度(dim)按参数split_size_or_sections进行分割，最终返回分割后的张量组成的元组(turple)； # 其中split_size可以是区间[ 1, tensor.shape[dim] ]的整数，表示每一次在指定维度(dim)分割的值(行数/列数)，最终分块张量的数量==tensor.shape[dim] / split_size的值 # 若除不尽，则分块张量的数量为最大商+1
pytorch每日一学40(torch.split())将张量拆分为块(tensor的分割)
Fluid_ray的博客
12-08 1万+
第40个方法 torch.split(tensor, split_size_or_sections, dim=0) 此方法和前面的torch.chunk()一样，都是将tensor进行切割的方法，但是这两有什么区别呢？其实我们split方法功能更多样一些。 看一下此方法的参数： tensor：要被切割的tensor。 split_size_or_sections：当此参数为整数时，意思是将tensor按照每块大小为split_size_or_sections来切割，当此参数为列表时，将此tensor切成
python中slice用法
一起躺躺躺的博客
05-06 1984
slice() 函数返回 slice 对象（切片）。 slice 对象用于指定如何对序列进行裁切。您可以指定在哪里开始裁切以及在哪里结束裁切。您还可以指定步进，例如只切每隔一个项目。 语法 slice(start, end, step) 默认为step为1 x = slice(2,6) print(x) #输出： slice(2, 6, None) y = torch.randn(6,7) print(y) print(y[x][:]) print(y[x,x]) 输出：y[x]..
python 中的内置函数slice()
越努力 越幸运
02-22 9329
slice()函数是一个切片函数，可以作用于list,tuple,numpy等结构，其作用类似于列表中常见的切片操作，但是如果按照某个长度将list等可以用于切片的序列做等分，一般可以用一个循环可以实现。 l =[1,2,3,4,5,6,7,8,9,10] i = 0 while(i<10): print(l[i:i+2]) i += 2 output： [1, 2] ...
c++ 部署libtorch时常用操作API
alex1801
11-10 7566
使用pytorch可以很方便的训练了网络，但是在部署libtorch的时候，c++对tensor的操作接口API，资料不是很多，因此，进行整理收集，形成文档。 目录 1、tensor创建 1.1、std::vector转tensor 1.2、torch::empty() 1.3、torch::ones() 1.4、torch::zeros() 1.5、torch::rand() 2、获取tensor属性 2.1、tensor.sizes()/numel() 2.2、获取tensor值
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值