def train():
train_set = torchvision.datasets.FashionMNIST(
root='./data/FashionMNIST',
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor()
])
)
params = OrderedDict(
lr=[0.01, 0.001],
batch_size=[100, 1000],
shuffle=[True, False],
num_workers=[2]
)
runManager = RunManager()
for run in RunBuilder.get_runs(params):
network = finalModel()
loader = DataLoader(
train_set, batch_size=run.batch_size, shuffle=run.shuffle, num_workers=run.num_workers)
optimizer = optim.Adam(network.parameters(), lr=run.lr)
runManager.begin_run(run, network, loader)
for epoch in range(10):
runManager.begin_epoch()
for batch in loader:
images, labels = batch
# support computation based on device type
images = images.to(get_device_type())
labels = labels.to(get_device_type())
preds = network(images)
loss = F.cross_entropy(preds, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
runManager.track_loss(loss)
runManager.track_num_correct(preds, labels)
runManager.end_epoch()
runManager.end_run()
runManager.save('results')
int(trainingSize * numOfTrainingSamples),
int(validationSize * numOfTrainingSamples)
]
# splits = splits.astype(int)
print(f"{splits}")
train_set, val_set = dataset.random_split(init_train_data, splits)
for run in RunBuilder.get_runs(params):
network = MyConvNet()
loader = DataLoader(train_set,
batch_size=run.batch_size,
num_workers=run.num_workers,
shuffle=run.shuffle)
optimizer = optim.Adam(network.parameters(), lr=run.lr)
m.begin_run(run, network, loader)
for epoch in range(50):
m.begin_epoch()
for batch in loader:
print(m.epoch_count)
images, labels = batch
preds = network(images)
loss = F.cross_entropy(preds, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
m.track_loss(loss)
m.track_num_correct(preds, labels)
m.end_epoch()
# 三、训练网络
for run in RunBuilder.get_runs(params):
device = torch.device(run.device)
# 生成模型实例
network = Network().to(device)
# 指定优化器,learning rate
optimizer = optim.Adam(network.parameters(), lr=run.lr)
# batch_size
data_loader = DataLoader(trainsets[run.trainset],
run.batch_size,
shuffle=run.shuffle,
num_workers=run.num_workers)
# record hyper-parameters
m.begin_run(run, network, data_loader)
# 循环训练
for epoch in range(5):
# record accuracy,loss……
m.begin_epoch()
for batch in data_loader:
# 解包
images = batch[0].to(device)
labels = batch[1].to(device)
# # 对标签进行独热编码
# enc = OneHotEncoder(sparse=False)
# # 一个train_data含有多个特征，使用OneHotEncoder时，特征和标签都要按列存放, sklearn都要用二维矩阵的方式存放
# one_hot_labels = enc.fit_transform(
# labels.reshape(-1, 1)) # 如果不加 toarray() 的话，输出的是稀疏的存储格式，即索引加值的形式，也可以通过参数指定 sparse = False 来达到同样的效果
# 预测
def __train_network(self, model, train_set, run, save_logistics_file_path, epochs, type_of_model, show_plot):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("-------------------------------------------------------------------", device)
loss_val = []
acc_val = []
batch_size = run.batch_size
lr = run.lr
shuffle = run.shuffle
# set batch size
data_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=shuffle, num_workers=1,
pin_memory=True)
save_file_name = save_logistics_file_path + self.__get_file_name(type_of_model, shuffle, lr, batch_size)
# model = self.__getModel(type_of_model)
tb_summary = self.__get_tb_summary_title(type_of_model)
# set optimizer - Adam
optimizer = optim.Adam(model.parameters(), lr=lr)
# initialise summary writer
run_manager = RunManager()
run_manager.begin_run(run, model, data_loader, device, tb_summary)
torch.backends.cudnn.enabled = False
# start training
for epoch in range(epochs):
run_manager.begin_epoch()
for batch in data_loader:
images, labels = batch
images = images.to(device)
labels = labels.to(device)
# forward propagation
predictions = model(images)
loss = F.cross_entropy(predictions, labels)
# zero out grads for every new iteration
optimizer.zero_grad()
# back propagation
loss.backward()
# update weights
# w = w - lr * grad_dw
optimizer.step()
run_manager.track_loss(loss)
run_manager.track_total_correct_per_epoch(predictions, labels)
run_manager.end_epoch()
loss_val.append(run_manager.get_final_loss_val())
acc_val.append(run_manager.get_final_accuracy())
run_manager.end_run()
run_manager.save(save_file_name)
if show_plot:
self.plot_loss_val(loss_val, run)
self.plot_accuracy_val(acc_val, run)
return model
