Epoch、Batch、tensor 张量

本文介绍了深度学习中的基本概念:Epoch是指使用训练集所有数据完整训练一次模型的过程;Batch是在训练中每次更新模型参数时使用的部分样本;Batch_Size即批大小,定义了每个Batch中样本的数量;张量是N维数组,可以从0D张量(标量)到高维张量,如向量、矩阵和3D张量等。张量的关键属性包括轴的数量(秩)、形状和数据类型。

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

  • Epoch
    使用训练集的全部数据对模型进行一次完整训练的过程,即“一次epoch”。

  • Batch
    使数据用训练集中*一小部分样本(一批数据)*对模型权重进行一次反向传播的参数更新,一个Epoch的样本可以分成多个Batch来进行训练。
    Batch_Size:批大小

  • Iteration
    使用一个Batch对模型进行一次参数更新的过程,即“一次迭代”。

  • tensor
    张量,将矩阵推广到任意维数的一种方法。例如矩阵就是2D张量。

  • sclars(0D张量)
    只包含一个数的张量称为标量(或标量张量,或0维张量,或0D张量)。在Numpy中,float32或float64数字是一个标量张量(或标量数组)。可以通过ndim属性显示Numpy张量的轴数;一个标量张量有0个轴(ndim == 0),张量的轴数也称为张量的秩。这是一个Numpy标量:

import numpy as np
x = np.array(12)
x
array(12)

x.ndim
0

  • Vectors(1D tensor)
    矢量(一维张量)一组数字称为矢量,或一维张量。一维张量据说只有一个轴。下面是一个Numpy向量:

x = np.array([12, 3, 6, 14])
x
array([12, 3, 6, 14])

<
首先,需要导入必要的库: ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import Dataset, DataLoader ``` 接下来,定义数据集类,继承自`Dataset`类,用于加载信号数据: ```python class SignalDataset(Dataset): def __init__(self, data, targets): self.data = data self.targets = targets def __len__(self): return len(self.data) def __getitem__(self, idx): sample = self.data[idx] target = self.targets[idx] return sample, target ``` 然后,定义LSTM模型类,继承自`nn.Module`类,用于分类: ```python class LSTMClassifier(nn.Module): def __init__(self, input_size, hidden_size, num_layers, num_classes): super(LSTMClassifier, self).__init__() self.hidden_size = hidden_size self.num_layers = num_layers self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, num_classes) def forward(self, x): # Set initial hidden and cell states h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device) c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device) # Forward propagate LSTM out, _ = self.lstm(x, (h0, c0)) # Decode the hidden state of the last time step out = self.fc(out[:, -1, :]) return out ``` 接下来,定义训练函数: ```python def train(model, train_loader, criterion, optimizer, device): model.train() for batch_idx, (data, targets) in enumerate(train_loader): data = data.to(device) targets = targets.to(device) # Forward pass outputs = model(data) loss = criterion(outputs, targets) # Backward and optimize optimizer.zero_grad() loss.backward() optimizer.step() if batch_idx % 100 == 0: print('Batch {} Loss: {:.4f}'.format(batch_idx, loss.item())) ``` 然后,定义测试函数: ```python def test(model, test_loader, criterion, device): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, targets in test_loader: data = data.to(device) targets = targets.to(device) # Forward pass outputs = model(data) test_loss += criterion(outputs, targets).item() # Get predicted class _, predicted = torch.max(outputs.data, 1) correct += (predicted == targets).sum().item() test_loss /= len(test_loader.dataset) accuracy = correct / len(test_loader.dataset) print('Test Loss: {:.4f}, Accuracy: {:.2f}%'.format(test_loss, 100 * accuracy)) ``` 接下来,加载数据集并进行预处理: ```python # Load data data = torch.load('data.pt') targets = torch.load('targets.pt') # Split into train and test sets train_data = data[:800] train_targets = targets[:800] test_data = data[800:] test_targets = targets[800:] # Create datasets and dataloaders train_dataset = SignalDataset(train_data, train_targets) test_dataset = SignalDataset(test_data, test_targets) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False) # Define device device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') ``` 最后,训练并测试模型: ```python # Define hyperparameters input_size = 512 hidden_size = 256 num_layers = 2 num_classes = 10 learning_rate = 0.001 num_epochs = 10 # Initialize model model = LSTMClassifier(input_size, hidden_size, num_layers, num_classes).to(device) # Define loss function and optimizer criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate) # Train and test model for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch+1, num_epochs)) train(model, train_loader, criterion, optimizer, device) test(model, test_loader, criterion, device) ``` 完整代码如下: ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import Dataset, DataLoader class SignalDataset(Dataset): def __init__(self, data, targets): self.data = data self.targets = targets def __len__(self): return len(self.data) def __getitem__(self, idx): sample = self.data[idx] target = self.targets[idx] return sample, target class LSTMClassifier(nn.Module): def __init__(self, input_size, hidden_size, num_layers, num_classes): super(LSTMClassifier, self).__init__() self.hidden_size = hidden_size self.num_layers = num_layers self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, num_classes) def forward(self, x): # Set initial hidden and cell states h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device) c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device) # Forward propagate LSTM out, _ = self.lstm(x, (h0, c0)) # Decode the hidden state of the last time step out = self.fc(out[:, -1, :]) return out def train(model, train_loader, criterion, optimizer, device): model.train() for batch_idx, (data, targets) in enumerate(train_loader): data = data.to(device) targets = targets.to(device) # Forward pass outputs = model(data) loss = criterion(outputs, targets) # Backward and optimize optimizer.zero_grad() loss.backward() optimizer.step() if batch_idx % 100 == 0: print('Batch {} Loss: {:.4f}'.format(batch_idx, loss.item())) def test(model, test_loader, criterion, device): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, targets in test_loader: data = data.to(device) targets = targets.to(device) # Forward pass outputs = model(data) test_loss += criterion(outputs, targets).item() # Get predicted class _, predicted = torch.max(outputs.data, 1) correct += (predicted == targets).sum().item() test_loss /= len(test_loader.dataset) accuracy = correct / len(test_loader.dataset) print('Test Loss: {:.4f}, Accuracy: {:.2f}%'.format(test_loss, 100 * accuracy)) # Load data data = torch.load('data.pt') targets = torch.load('targets.pt') # Split into train and test sets train_data = data[:800] train_targets = targets[:800] test_data = data[800:] test_targets = targets[800:] # Create datasets and dataloaders train_dataset = SignalDataset(train_data, train_targets) test_dataset = SignalDataset(test_data, test_targets) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False) # Define device device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Define hyperparameters input_size = 512 hidden_size = 256 num_layers = 2 num_classes = 10 learning_rate = 0.001 num_epochs = 10 # Initialize model model = LSTMClassifier(input_size, hidden_size, num_layers, num_classes).to(device) # Define loss function and optimizer criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate) # Train and test model for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch+1, num_epochs)) train(model, train_loader, criterion, optimizer, device) test(model, test_loader, criterion, device) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值