Pytorch_Dataloader

Preliminary

数据集: Pima Indians Diabetes dataset.
设置: 33% for testing, standardize it and set the batch size to 64.

import pandas as pd
import torch
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import torch.nn as nn

df = pd.read_csv(r'https://raw.githubusercontent.com/a-coders-guide-to-ai/a-coders-guide-to-neural-networks/master/data/diabetes.csv')
# df.head()

X = df[df.columns[:-1]]
y = df["Outcome"]
X = X.values
y = torch.tensor(y.values)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)

scaler = StandardScaler()
scaler.fit(X_train)
X_train = torch.tensor(scaler.transform(X_train))
X_test = torch.tensor(scaler.transform(X_test))

构建模型

class Model(nn.Module):
    
    def __init__(self):
        super().__init__()
        self.hidden_linear = nn.Linear(8, 4)
        self.output_linear = nn.Linear(4, 1)
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, X):
        hidden_output = self.sigmoid(self.hidden_linear(X))
        output = self.sigmoid(self.output_linear(hidden_output))
        return output

def accuracy(y_pred, y):
    return torch.sum((((y_pred>=0.5)+0).reshape(1,-1)==y)+0).item()/y.shape[0]
epochs = 1000+1
print_epoch = 100
lr = 1e-2
batch_size = 64

model = Model()
BCE = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr = lr)

不使用DataLoader进行模型训练

import numpy as np
train_batches = int(np.ceil(len(X_train)/batch_size))-1
test_batches = int(np.ceil(len(X_test)/batch_size))-1
for epoch in range(epochs):
    
    iteration_loss = 0.
    iteration_accuracy = 0.
    
    model.train()
    for i in range(train_batches):
      beg = i*batch_size
      end = (i+1)*batch_size
      y_pred = model(X_train[beg:end].float())
      loss = BCE(y_pred, y_train[beg:end].reshape(-1,1).float())     
      
      iteration_loss += loss
      iteration_accuracy += accuracy(y_pred, y_train[beg:end])
      optimizer.zero_grad()
      loss.backward()
      optimizer.step()
    if(epoch % print_epoch == 0):
      print('Train: epoch: {0} - loss: {1:.5f}; acc: {2:.3f}'.format(epoch, iteration_loss/(i+1), iteration_accuracy/(i+1)))
    iteration_loss = 0.
    iteration_accuracy = 0.
    model.eval()
    for i in range(test_batches):
      beg = i*batch_size
      end = (i+1)*batch_size
      
      y_pred = model(X_test[beg:end].float())
      loss = BCE(y_pred, y_test[beg:end].reshape(-1,1).float())
      
      iteration_loss += loss
      iteration_accuracy += accuracy(y_pred, y_test[beg:end])
      
    if(epoch % print_epoch == 0):
      print('Test: epoch: {0} - loss: {1:.5f}; acc: {2:.3f}'.format(epoch, iteration_loss/(i+1), iteration_accuracy/(i+1)))

使用DataLoader进行模型训练

from torch.utils.data import Dataset
from torch.utils.data import DataLoader

如果想要构建自己的数据迭代器，我们需要创建一个继承自Dataset的类。在构建数据类时，除了需要设置init方法，还需要重写Dataset中的getitem和len方法。其中，len方法用来返回数据长度，getitem方法返回给定索引对应的xy。

class PimaIndiansDiabetes(Dataset):
    def __init__(self, X, y):
        self.X = X
        self.y = y
        self.len = len(self.X)

    def __getitem__(self, index):
        return self.X[index], self.y[index]
        
    def __len__(self):
        return self.len

train_data = PimaIndiansDiabetes(X_train, y_train)
test_data = PimaIndiansDiabetes(X_test, y_test)

Shuffle: 每个epoch都会对数据进行一次shuffle
drop_last: 如果数据量小于batch_size，是否丢弃这些数据

train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True, drop_last=True)
test_loader = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=True, drop_last=True)

训练模型

model = Model()
BCE = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr = lr)

for epoch in range(epochs):
    
    iteration_loss = 0.
    iteration_accuracy = 0.
    
    model.train()
    for i, data in enumerate(train_loader):
      X, y = data
      y_pred = model(X.float())
      loss = BCE(y_pred, y.reshape(-1,1).float())     
      
      iteration_loss += loss
      iteration_accuracy += accuracy(y_pred, y)
      optimizer.zero_grad()
      loss.backward()
      optimizer.step()
    if(epoch % print_epoch == 0):
       print('Train: epoch: {0} - loss: {1:.5f}; acc: {2:.3f}'.format(epoch, iteration_loss/(i+1), iteration_accuracy/(i+1)))
    iteration_loss = 0.
    iteration_accuracy = 0.
    model.eval()
    for i, data in enumerate(test_loader):
      X, y = data
      y_pred = model(X.float())
      loss = BCE(y_pred, y.reshape(-1,1).float())
      iteration_loss += loss
      iteration_accuracy += accuracy(y_pred, y)
    if(epoch % print_epoch == 0):
       print('Test: epoch: {0} - loss: {1:.5f}; acc: {2:.3f}'.format(epoch, iteration_loss/(i+1), iteration_accuracy/(i+1)))

Reference

Why You Need to Learn PyTorch’s Powerful DataLoader