day19 Tensor 操作1 入门 一起学 PyTorch吧,PyTorch从入门开始 每天都更新 超详细 参数 常用方法 简单案列 共同学习,共同进步 坚持

本文介绍了PyTorch中的张量概念及其基本操作方法。详细解释了如何创建不同类型的张量,包括从列表构建张量及创建空张量等。此外,还说明了如何通过索引和切片来访问和修改张量中的数据。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

torch.Tensor 是一种包含单一数据类型元素的多维矩阵。Torch 定义了七种 CPU tensor类型和八种 GPU tensor 类型:
        torch.Tensor 是默认的 tensor 类型( torch.FloatTensor )的简称。
         一个张量 tensor 可以从 Python list 或序列构建:
例子:
>>> torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
1 2 3 
4 5 6 
[torch.FloatTensor of size 2x3]

        一个空张量 tensor 可以通过规定其大小来构建:

例子:

>>> torch.IntTensor(2, 4).zero_()
0 0 0 0 
0 0 0 0 
[torch.IntTensor of size 2x4]

        可以用 python 的索引和切片来获取和修改一个张量 tensor 中的内容:

例子:

>>> x = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
>>> print(x[1][2])
6.0
>>> x[0][1] = 8
>>> print(x) 
1 8 3 
4 5 6 
[torch.FloatTensor of size 2x3]
每一个张量 tensor 都有一个相应的 torch.Storage 用来保存其数据。类tensor 提供了一个存储的多维的、横向视图,并且定义了在数值运算。
注:会改变tensor的函数操作会用一个下划线后缀来标示。比如,torch.FloatTensor_()会在原地计算绝对值,并返回改变后的tensor,而tensor.FloatTensor.abs()将会在一个新的tensor中计算结果。
class torch.Tensor
class torch.Tensor(*sizes)
class torch.Tensor(size)
class torch.Tensor(sequence)
class torch.Tensor(ndarray)
class torch.Tensor(tensor)
class torch.Tensor(storage)
根据可选择的大小和数据新建一个 tensor。如果没有提供参数,将会返回一个空的零维张量。如果提供了 numpy.ndarray,torch.Tensor 或 torch.Storage将会返回一个有同样参数的 tensor. 如果提供了 python 序列, 将会从序列的副本创建一个 tensor
        abs() –>Tensor请查看 torch.abs()
        abs_() –>Tensor abs() in-place 运算形式
        acos() –>Tensor 请查看 torch.acos()
        acos_() –>Tensor:acos() in-place 运算形式
        add(value) 请查看 torch.add()
         add_(value) add() in-place 运算形式
        addbmm(beta=1, mat, alpha=1, batch1, batch2) –>Tensor 请查看 torch.addbmm()
        addbmm_(beta=1, mat, alpha=1, batch1, batch2) –>Tensor addbmm() 的 in-place 运
算形式
        addcdiv(value=1, tensor1, tensor2) –>Tensor 请查看 torch.addcdiv()
         addcdiv_(value=1, tensor1, tensor2) –>Tensor addcdiv() in-place 运算形式
        addcmul(value=1, tensor1, tensor2) –>Tensor 请查看 torch.addcmul()
         addcmul_(value=1, tensor1, tensor2) –>Tensor addcmul() in-place 运算形式
        addmm(beta=1, mat, alpha=1, mat1, mat2) –>Tensor 请查看 torch.addmm()
        addmm_(beta=1, mat, alpha=1, mat1, mat2) –>Tensor addmm() in-place 运算形式
        addmv(beta=1, tensor, alpha=1, mat, vec) –>Tensor 请查看 torch.addmv()
         addmv_(beta=1, tensor, alpha=1, mat, vec) –>Tensor addmv() in-place 运算形式
        addr(beta=1, alpha=1, vec1, vec2) –>Tensor 请查看 torch.addr()
        addr_(beta=1, alpha=1, vec1, vec2) –>Tensor addr() in-place 运算形式
         apply_(callable) –>Tensor 将函数 callable 作用于 tensor 中每一个元素,并将每个元 素用callable函数返回值替代。
         该函数只能在 CPU tensor 中使用,并且不应该用在有较高性能要求的代码块。
        
以下示例给出了使用PyTorch构建3层1D CNN LSTM Attention网络模型以进行风速预测的一种方法: 首先,我们需要导入所需的库和数据集。例如,我们使用UCI机器学习库中的气象数据集。 ```python import torch import torch.nn as nn from torch.autograd import Variable from torch.utils.data import DataLoader, Dataset import pandas as pd import numpy as np # Load data cols = ['year', 'month', 'day', 'hour', 'PM2.5', 'DEWP', 'TEMP', 'PRES', 'cbwd', 'Iws', 'Is', 'Ir'] df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/00381/PRSA_data_2010.1.1-2014.12.31.csv', header=0, names=cols).fillna(0) ``` 然后,我们需要对数据集进行适当的处理和变换。例如,我们将在此处为每个数据点定义一个时间序列,并将其随机分割成训练集和测试集。 ```python # Define time series df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour']]) df = df.set_index('time') df = df.drop(['year', 'month', 'day', 'hour'], axis=1) # Set training and test data train_size = int(len(df) * 0.70) train_data, test_data = df.iloc[:train_size], df.iloc[train_size:] ``` 接下来,我们需要为模型创建一个数据集类。我们需要定义数据点的长度和要使用的特征。 ```python # Define Dataset class class WindDataset(Dataset): def __init__(self, data, window_size=24, features=['DEWP', 'TEMP', 'PRES', 'Iws', 'Is', 'Ir']): self.data = data[features].values self.targets = data['PM2.5'].values self.window_size = window_size def __len__(self): return len(self.data) - self.window_size def __getitem__(self, index): return { 'x': torch.tensor(self.data[index:index+self.window_size], dtype=torch.float32), 'y': torch.tensor(self.targets[index+self.window_size], dtype=torch.float32) } ``` 然后,我们需要为模型定义一个1D CNN层。我们将使用3个卷积核和ReLU激活函数。 ```python # Define 1D CNN layer class CNN1D(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=3, stride=1): super(CNN1D, self).__init__() self.conv = nn.Conv1d(in_channels, out_channels, kernel_size=kernel_size, stride=stride) self.relu = nn.ReLU() def forward(self, x): x = self.conv(x) x = self.relu(x) return x ``` 接下来,我们需要为模型定义一个LSTM层。我们将使用2个隐藏层和一个输出层。每一层都有64个LSTM单元。在每个时间步长上,LSTM层的输出将作为1D CNN层的输入。 ```python # Define LSTM layer class LSTM(nn.Module): def __init__(self, input_dim, hidden_dim, batch_size, num_layers): super(LSTM, self).__init__() self.input_dim = input_dim self.hidden_dim = hidden_dim self.batch_size = batch_size self.num_layers = num_layers self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=num_layers) self.hidden = self.init_hidden() def init_hidden(self): hidden = (torch.zeros(self.num_layers, self.batch_size, self.hidden_dim), torch.zeros(self.num_layers, self.batch_size, self.hidden_dim)) return hidden def forward(self, x): lstm_out, self.hidden = self.lstm(x.view(len(x), self.batch_size, -1), self.hidden) return lstm_out[-1] # Define model class Net(nn.Module): def __init__(self, input_dim, cnn_channels, cnn_kernel_size, cnn_stride, lstm_hidden_dim, lstm_num_layers): super(Net, self).__init__() self.cnn = CNN1D(input_dim, cnn_channels, kernel_size=cnn_kernel_size, stride=cnn_stride) self.lstm = LSTM(cnn_channels, lstm_hidden_dim, batch_size=1, num_layers=lstm_num_layers) self.attention = nn.Linear(lstm_hidden_dim, 1) self.out = nn.Linear(lstm_hidden_dim, 1) def forward(self, x): cnn_out = self.cnn(x) lstm_out = self.lstm(cnn_out) attention_out = self.attention(lstm_out) attention_weights = torch.softmax(attention_out, dim=0) attention_applied = attention_weights * lstm_out out = self.out(attention_applied) return out.squeeze() ``` 最后,我们需要定义要使用的超参数。这些可以根据实际情况进行更改。 ```python # Define hyperparameters window_size = 24 input_dim = 6 cnn_channels = 64 cnn_kernel_size = 3 cnn_stride = 1 lstm_hidden_dim = 64 lstm_num_layers = 2 learning_rate = 0.001 num_epochs = 50 batch_size = 32 ``` 然后,我们可以训练模型并针对测试数据评估其性能。 ```python # Train model train_dataset = WindDataset(train_data, window_size=window_size) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) net = Net(input_dim, cnn_channels, cnn_kernel_size, cnn_stride, lstm_hidden_dim, lstm_num_layers) criterion = nn.MSELoss() optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) for epoch in range(num_epochs): for batch in train_loader: x = batch['x'] y_true = batch['y'] optimizer.zero_grad() y_pred = net(x) loss = criterion(y_pred, y_true) loss.backward() optimizer.step() # Evaluate model test_dataset = WindDataset(test_data, window_size=window_size) test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False) y_pred_list = [] y_true_list = [] with torch.no_grad(): for batch in test_loader: x = batch['x'] y_true = batch['y'] y_pred = net(x) y_pred_list.append(y_pred.item()) y_true_list.append(y_true.item()) rmse = np.sqrt(np.mean((np.array(y_pred_list) - np.array(y_true_list))**2)) print(f'Epoch: {epoch}, RMSE: {rmse:.3f}') ``` 最后,我们可以使用该模型进行预测,例如: ```python # Make prediction test_point = np.array([[-9, 0.1, 1016, 23, 0, 0]]) net.eval() with torch.no_grad(): pred = net(torch.tensor(test_point, dtype=torch.float32)) print(f'Predicted wind speed: {pred.item():.3f} m/s') ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值