Torch建立数据迭代器进行训练的两种方法_利用生成器训练批数据给torch模型训练

数据库的建立

数据格式要求：.csv文件，第一列为标签，第二列之后为数据
建立数据库代码

import torch
import pandas as pd
import torch.utils.data as Data

def dataset(path):
    data = pd.read_csv(path,header=None)
    label = data.iloc[:, 0]
    data = data.iloc[:, 1:]
    label = torch.from_numpy(label.values.reshape(len(label))).type(torch.LongTensor)
    data = torch.from_numpy(data.values.astype(float).reshape(len(data), 1, len(data.loc[0]))).type(torch.FloatTensor)
    dataset = Data.TensorDataset(data, label)
    return dataset

path = './example.csv'
source_loader = Data.DataLoader(dataset=dataset(path), batch_size=8, shuffle=True, drop_last = True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

方法一

在训练和测试时需要调用建立的数据库，使用iter方法逐行调用

from torch.autograd import Variable

for epoch in range(1,EPOCH+1):
    # 开始训练
    # 模型model需要提前声明***
	model.train()
    iter_source = iter(source_loader)
    num_iter = len(source_loader)
    for i in range(0, num_iter):
        data, label = iter_source.next()
        if torch.cuda.is_available():
            data, label = data.cuda(), label.cuda()
        data, label = Variable(data), Variable(label)
        # 到此为止，数据调用完成，开始训练
        # 优化器optimizer需要提前声明***
        optimizer.zero_grad()
        preds = model(data)
        # 损失函数loss_func需要提前声明***
        loss= loss_func(preds, label)
        loss.backward()
        optimizer.step() 
        
    # 开始测试，test_loader同source_loader相同，需要提前定义***
    model.eval()
    iter_target = iter(test_loader)
    num_iter = len(test_loader)
    for i in range(0, num_iter):
        data, label = iter_target.next()
        if torch.cuda.is_available():
            data, label = data.cuda(), label.cuda()
        # 测试模式下不需要训练梯度
        with torch.no_grad():
            data, label = Variable(data), Variable(label)
        preds = model(data)
        loss = loss_func(target_preds, source_label)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

方法二

使用enumerate方法调用数据库，直接使用cuda类型的数据，使用CPU训练需要修改格式

for epoch in range(1,EPOCH+1):
    model.train() 
    for step1,(data, label) in enumerate(train_loader):
        data = Variable(data.type('torch.cuda.FloatTensor'))
        label = Variable(label.type('torch.cuda.LongTensor'))
        optimizer.zero_grad()
        preds = model(data)
        loss = loss_func(preds, label)
        loss.backward()
        optimizer.step()  
    model.eval()     
    for step2,(data, label) in enumerate(test_loader):
        with torch.no_grad():
            data = Variable(data.type('torch.cuda.FloatTensor'))
            label = label.type('torch.cuda.LongTensor')
        preds = model(data)
        loss = loss_func(output, label)   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17