pytorch如何生成小批量数据并传入神经网络？

た入场券 2024-02-05 11:04 2阅读 0赞

#### pytorch如何生成小批量数据并传入神经网络？ ####

*  第一部分：Excel表格数据的预处理
 *   *  1.1 加载Excel数据
     *  1.2 数据清洗
     *   *  1.2.1 删除无用数据
         *  1.2.2 填充缺失值
         *  1.2.3 数据类型转换
     *  1.3 将数据转换为张量
     *  1.4 创建数据集和数据加载器
     *   *  1.4.1 创建数据集
         *  1.4.2 创建数据加载器
 *  第二部分：CSV文件数据的预处理
 *   *  2.1 加载CSV数据
     *  2.2 数据清洗
     *  2.3 将数据转换为张量
     *  2.4 创建数据集和数据加载器
 *  第三部分：随机生成数据的预处理
 *   *  3.1 生成随机数据
     *  3.2 将数据转换为张量
     *  3.3 创建数据集和数据加载器
 *  第四部分：神经网络模型的构建和训练
 *   *  4.1 定义神经网络模型
     *  4.2 定义损失函数和优化
     *  4.3 训练模型
 *  第五部分：完整代码示例
 *  第六部分：结论

> 本文将为大家介绍如何将Excel表格、CSV文件、以及随机生成的数据转换为能够输入到PyTorch神经网络中的小批量数据。

我们将分别介绍这三种情况，并提供详细的Python代码示例，以帮助读者深入理解数据预处理的过程。

## 第一部分：Excel表格数据的预处理 ##

### 1.1 加载Excel数据 ###

我们首先需要安装pandas库，这个库是Python中用于处理表格数据的标准库。我们可以使用pandas库中的read\_excel函数来读取Excel文件中的数据。下面是一个简单的代码示例：

import pandas as pd
    
    # 读取Excel文件
    df = pd.read_excel('data.xlsx')
    
    # 显示前5行数据
    print(df.head())

### 1.2 数据清洗 ###

在读取Excel数据之后，我们需要对数据进行清洗。数据清洗是指将数据中的无效值、缺失值、重复值等无用数据删除或填充，使数据更加规范、准确。

#### 1.2.1 删除无用数据 ####

我们可以使用pandas库中的drop函数来删除无用数据。下面是一个代码示例：

# 删除“ID”列
    df.drop(['ID'], axis=1, inplace=True)
    
    # 删除含有缺失值的行
    df.dropna(inplace=True)
    
    # 删除重复的行
    df.drop_duplicates(inplace=True)
    
    # 重新设置索引
    df.reset_index(drop=True, inplace=True)

#### 1.2.2 填充缺失值 ####

如果数据中存在缺失值，我们可以使用pandas库中的fillna函数来填充缺失值。下面是一个代码示例：

# 将缺失值填充为0
    df.fillna(0, inplace=True)

#### 1.2.3 数据类型转换 ####

在对数据进行清洗之后，我们需要对数据类型进行转换。在机器学习中，通常需要将数据转换为浮点数或整数类型。

# 将“年龄”列转换为整数类型
    df['Age'] = df['Age'].astype(int)
    
    # 将“收入”列转换为浮点数类型
    df['Income'] = df['Income'].astype(float)

### 1.3 将数据转换为张量 ###

在数据清洗之后，我们需要将数据转换为张量，以便于将其输入到神经网络中。我们可以使用torch库中的Tensor函数来创建张量。下面是一个代码示例：

import torch
    
    # 将数据转换为张量
    data = torch.Tensor(df.values)

### 1.4 创建数据集和数据加载器 ###

最后，我们需要将数据集分为训练集和测试集，并创建相应的数据加载器。我们可以使用torch.utils.data中的Dataset和DataLoader类来实现这一过程

#### 1.4.1 创建数据集 ####

在创建数据集时，我们需要定义\_\_len\_\_和\_\_getitem\_\_函数。其中\_\_len\_\_函数返回数据集的大小，\_\_getitem\_\_函数根据给定的索引返回数据集中的数据。下面是一个代码示例：

from torch.utils.data import Dataset
    
    class ExcelDataset(Dataset):
        def __init__(self, data):
            self.data = data
    
        def __len__(self):
            return len(self.data)
    
        def __getitem__(self, index):
            x = self.data[index, :-1] # 输入数据
            y = self.data[index, -1] # 输出数据
            return x, y

#### 1.4.2 创建数据加载器 ####

在创建数据加载器时，我们需要指定批量大小和是否对数据进行随机打乱。下面是一个代码示例：

from torch.utils.data import DataLoader
    
    # 创建训练集和测试集
    train_data = data[:800, :]
    test_data = data[800:, :]
    
    # 创建训练集和测试集的数据集
    train_dataset = ExcelDataset(train_data)
    test_dataset = ExcelDataset(test_data)
    
    # 创建训练集和测试集的数据加载器
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

## 第二部分：CSV文件数据的预处理 ##

### 2.1 加载CSV数据 ###

与加载Excel数据类似，我们可以使用pandas库中的read\_csv函数来读取CSV文件中的数据。下面是一个简单的代码示例：

import pandas as pd
    
    # 读取CSV文件
    df = pd.read_csv('data.csv')
    
    # 显示前5行数据
    print(df.head())

### 2.2 数据清洗 ###

在读取CSV数据之后，我们需要对数据进行清洗。数据清洗的过程与Excel数据清洗的过程类似，我们不再赘述。

### 2.3 将数据转换为张量 ###

在数据清洗之后，我们需要将数据转换为张量。与Excel数据转换类似，我们可以使用torch库中的Tensor函数来创建张量。下面是一个代码示例：

import torch
    
    # 将数据转换为张量
    data = torch.Tensor(df.values)

### 2.4 创建数据集和数据加载器 ###

在创建数据集和数据加载器时，与Excel数据相似，我们同样需要定义\_\_len\_\_和\_\_getitem\_\_函数，并使用torch.utils.data中的Dataset和DataLoader类来创建数据集和数据加载器。下面是一个代码示例：

from torch.utils.data import Dataset, DataLoader
    
    class CSVDataset(Dataset):
        def __init__(self, data):
            self.data = data
    
        def __len__(self):
            return len(self.data)
    
        def __getitem__(self, index):
            x = self.data[index, :-1] # 输入数据
            y = self.data[index, -1] # 输出数据
            return x, y
    
    # 创建训练集和测试集
    train_data = data[:800, :]
    test_data = data[800:, :]
    
    # 创建训练集和测试集的数据集
    train_dataset = CSVDataset(train_data)
    test_dataset = CSVDataset(test_data)
    
    # 创建训练集和测试集的数据加载器
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

## 第三部分：随机生成数据的预处理 ##

### 3.1 生成随机数据 ###

# 在生成随机数据时，我们可以使用`numpy`库中的`random`函数来生成一定数量的随机数据。下面是一个代码示例：
    import numpy as np
    # 生成1000个随机数据
    data = np.random.rand(1000, 5)
    # 显示前5行数据
    print(data[:5])

### 3.2 将数据转换为张量 ###

在生成随机数据之后，我们同样需要将数据转换为张量。与Excel数据和CSV数据转换类似，我们可以使用torch库中的Tensor函数来创建张量。下面是一个代码示例：

import torch
    
    # 将数据转换为张量
    data = torch.Tensor(data)

### 3.3 创建数据集和数据加载器 ###

在创建数据集和数据加载器时，与Excel数据和CSV数据相似，我们同样需要定义\_\_len\_\_和\_\_getitem\_\_函数，并使用torch.utils.data中的Dataset和DataLoader类来创建数据集和数据加载器。下面是一个代码示例：

from torch.utils.data import Dataset, DataLoader
    
    class RandomDataset(Dataset):
        def __init__(self, data):
            self.data = data
    
        def __len__(self):
            return len(self.data)
    
        def __getitem__(self, index):
            x = self.data[index, :-1] # 输入数据
            y = self.data[index, -1] # 输出数据
            return x, y
    
    # 创建训练集和测试集
    train_data = data[:800, :]
    test_data = data[800:, :]
    
    # 创建训练集和测试集的数据集
    train_dataset = RandomDataset(train_data)
    test_dataset = RandomDataset(test_data)
    
    # 创建训练集和测试集的数据加载器
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

## 第四部分：神经网络模型的构建和训练 ##

### 4.1 定义神经网络模型 ###

在定义神经网络模型时，我们可以使用torch.nn中的模块来构建神经网络。下面是一个简单的多层感知机模型的代码示例：

import torch.nn as nn
    
    class MLP(nn.Module):
        def __init__(self):
            super(MLP, self).__init__()
            self.fc1 = nn.Linear(4, 10)
            self.fc2 = nn.Linear(10, 2)
    
        def forward(self, x):
            x = nn.functional.relu(self.fc1(x))
            x = self.fc2(x)
            return x

### 4.2 定义损失函数和优化 ###

在定义损失函数和优化器时，我们可以使用torch.nn和torch.optim中的函数来定义。下面是一个代码示例：

import torch.nn as nn
    import torch.optim as optim
    
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.001)

### 4.3 训练模型 ###

在训练模型时，我们需要遍历整个数据集并更新模型的权重。下面是一个代码示例：

# 定义训练函数
    def train(model, train_loader, criterion, optimizer, epoch):
        model.train()
        for batch_idx, (data, target) in enumerate(train_loader):
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            if batch_idx % 10 == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch, batch_idx * len(data), len(train_loader.dataset),
                    100. * batch_idx / len(train_loader), loss.item()))
    
    # 定义测试函数
    def test(model, test_loader, criterion):
        model.eval()
        test_loss = 0
        correct = 0
        with torch.no_grad():
            for data, target in test_loader:
                output = model(data)
                test_loss += criterion(output, target).item()
                pred = output.argmax(dim=1, keepdim=True)
                correct += pred.eq(target.view_as(pred)).sum().item()
    
        test_loss /= len(test_loader.dataset)
        print('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))
    
    # 训练模型
    for epoch in range(1, 11):
        train(model, train_loader, criterion, optimizer, epoch)
        test(model, test_loader, criterion)

## 第五部分：完整代码示例 ##

import pandas as pd
    import numpy as np
    import torch
    from torch.utils.data import Dataset, DataLoader
    import torch.nn as nn
    import torch.optim as optim
    
    # 第一部分：Excel数据的预处理
    
    # 读取Excel文件
    dataframe = pd.read_excel('data.xlsx')
    data = dataframe.to_numpy()
    
    # 将数据转换为张量
    data = torch.Tensor(data)
    
    # 创建数据集和数据加载器
    class ExcelDataset(Dataset):
        def __init__(self, data):
            self.data = data
    
        def __len__(self):
            return len(self.data)
    
        def __getitem__(self, index):
            x = self.data[index, :-1] # 输入数据
            y = self.data[index, -1] # 输出数据
            return x, y
    
    train_data = data[:800, :]
    test_data = data[800:, :]
    
    train_dataset = ExcelDataset(train_data)
    test_dataset = ExcelDataset(test_data)
    
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
    
    # 第二部分：CSV数据的预处理
    
    # 读取CSV文件
    dataframe = pd.read_csv('data.csv', header=None)
    data = dataframe.to_numpy()
    
    # 将数据转换为张量
    data = torch
    Tensor(data)
    
    # 创建数据集和数据加载器
    class CSVDataset(Dataset):
    	def init(self, data):
    		self.data = data
        def __len__(self):
        	return len(self.data)
    
        def __getitem__(self, index):
            x = self.data[index, :-1] # 输入数据
            y = self.data[index, -1] # 输出数据
            return x, y

train_data = data[:800, :]
    test_data = data[800:, :]
    
    train_dataset = CSVDataset(train_data)
    test_dataset = CSVDataset(test_data)
    
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

第三部分：随机生成数据的预处理

# 
    # 随机生成数据
    data = np.random.rand(1000, 5)
    data = np.concatenate((data, np.random.randint(0, 2, size=(1000, 1))), axis=1)
    
    # 将数据转换为张量
    data = torch.Tensor(data)
    
    # 创建数据集和数据加载器
    class RandomDataset(Dataset):
    	def init(self, data):
    		self.data = data
        def __len__(self):
        	return len(self.data)
    
        def __getitem__(self, index):
            x = self.data[index, :-1] # 输入数据
            y = self.data[index, -1] # 输出数据
            return x, y

train_data = data[:800, :]
    test_data = data[800:, :]
    
    train_dataset = RandomDataset(train_data)
    test_dataset = RandomDataset(test_data)
    
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

第四部分：定义模型、损失函数和优化器

# 
    # 定义模型
    class Net(nn.Module):
    	def init(self):
    		super(Net, self).init()
    		self.fc1 = nn.Linear(5, 10)
    		self.fc2 = nn.Linear(10, 2)
        def forward(self, x):
        	x = torch.relu(self.fc1(x))
        	x = self.fc2(x)
        	return x
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.001)

第五部分：训练模型

# 
    # 定义训练函数
    def train(model, train_loader, criterion, optimizer, epoch):
    	model.train()
    	for batch_idx, (data, target) in enumerate(train_loader):
    	optimizer.zero_grad()
    	output = model(data)
    	loss = criterion(output, target)
    	loss.backward()
    	optimizer.step()
    	if batch_idx % 10 == 0:
    		print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
    			epoch, batch_idx * len(data), len(train_loader.dataset),
    				100. * batch_idx / len(train_loader), loss.item()))
    
    # 定义测试函数
    def test(model, test_loader, criterion):
    	model.eval()
    	test_loss = 0
    	correct = 0
    	with torch.no_grad():
    	for data, target in test_loader:
    		output = model(data)
    		test_loss += criterion(output, target).item()
    		pred = output.argmax(dim=1, keepdim=True)
    		correct += pred.eq(target.view_as(pred)).sum().item()
            test_loss

第六部分：训练和测试模型

# 
    # 训练模型
    
    for epoch in range(1, 11):
    	train(model, train_loader, criterion, optimizer, epoch)
    
    # 测试模型
    test_loss = test(model, test_loader, criterion)
    test_accuracy = 100. * correct / len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, len(test_loader.dataset), test_accuracy))
    
    # 第七部分：保存和加载模型
    # 保存模型
    torch.save(model.state_dict(), 'model.pth')
    
    # 加载模型
    model.load_state_dict(torch.load('model.pth'))

## 第六部分：结论 ##

在本文中，我们介绍了如何将Excel的数据、CSV文件数据和随机生成的数据转换为能够放入神经网络的小批量数据。

我们使用了PyTorch中的数据集和数据加载器来处理数据，并定义了一个简单的神经网络模型，使用交叉熵损失和随机梯度下降优化器来训练模型。我们还展示了如何保存和加载模型，以便在以后使用。希望本文对初学者有所帮助。