08加载数据集

加载数据集

import numpy as np
import torch
import matplotlib.pyplot as plt
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

# dataloader，需要有index和len

# 实例化dataset
class DiabetesDataset(Dataset):
    def __init__(self, filepath):
        xy = np.loadtxt(fname=filepath, delimiter=',', skiprows=1, dtype=np.float32)
        self.len = xy.shape[0]
        self.x_data = torch.from_numpy(xy[:, :-1])
        self.y_data = torch.from_numpy(xy[:, [-1]])

    def __getitem__(self, item):
        return self.x_data[item], self.y_data[item]

    def __len__(self):
        return self.len
dataset = DiabetesDataset("./datasets/diabetes.csv")
# 读取数据集
dataloader = DataLoader(dataset=dataset, batch_size=32, shuffle=True)


# 定义模型
class DiabetesModel(torch.nn.Module):
    def __init__(self):
        super(DiabetesModel, self).__init__()
        self.linear1 = torch.nn.Linear(8, 6)
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.relu = torch.nn.ReLU()
        self.sigmoid = torch.nn.Sigmoid()

    def forward(self, x):
        x = self.relu(self.linear1(x))
        x = self.relu(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return x
model = DiabetesModel()    # 实例化
# model = model.cuda()
# 定义loss和optimizer
criterion = torch.nn.BCELoss(reduction='mean')
# criterion = criterion.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

loss = []

if __name__ == '__main__':    # Windows的多处理模块和Linux不同，需要先封装到函数里
    for epoch in range(100):
        for i, data in enumerate(dataloader, 0):   # 获取迭代次数和数据tensor
            # prepare data
            x, y = data
            # x, y = x.cuda(), y.cuda()
            # forward
            y_pred = model(x)
            l = criterion(y_pred, y)
            # backward
            optimizer.zero_grad()   # 清零
            l.backward()
            # update
            optimizer.step()
        loss.append(l.item())
        print(f"epoch: {epoch}, loss: {l.item()}")

# 画图
loss = np.array(loss)
plt.plot(range(100), loss)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()
plt.close()



# 加载mnist
from torchvision import datasets
from torchvision import transforms

train = datasets.MNIST(train=True, root="./datasets/mnist", download=True, transform=transforms.ToTensor())
test = datasets.MNIST(root="./datasets/mnist", download=True, train=False, transform=transforms.ToTensor())

tra_loader = DataLoader(dataset=train, shuffle=True, batch_size=32)
test_loader = DataLoader(dataset=test, shuffle=False, batch_size=32)  # val不打乱方便观察对比

for i, (inputs, labels) in enumerate(tra_loader):
    pass