def main(session=1, mode='subject_dependent'):
os.environ['CUDA_VISIBLE_DEVICES'] = '4'
# prepare data
session = session
balance = True
shuffle = False
modal = 'concat'
nor_method = 1
# reading the data in the whole dataset
all_individual_data = []
for i in range(1, 16):
print("contructing dataset...")
eeg = SEED_IV(session=session, individual=i, modal=modal, shuffle=shuffle, balance=balance,
normalization=nor_method)
_train_X, _train_Y = eeg.get_train_data()
_test_X, _test_Y = eeg.get_test_data()
all_individual_data.append([(_train_X, _train_Y), (_test_X, _test_Y)])
# Hyper-parameters
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
epochs = 50
batch_size = 64
learning_rate = 1e-3
criterion = CrossEntropyLoss()
for idx in range(1, 16):
if mode == 'subject_dependent':
train_X, train_Y = all_individual_data[idx-1][0][0], all_individual_data[idx-1][0][1]
test_X, test_Y = all_individual_data[idx-1][1][0], all_individual_data[idx-1][1][1]
exp_des = "%d_dependent_in_seesion_%d_%s_%s_%s_%d_%d" % (
idx, session, 'balance' if balance else 'without_balance',
'shuffle' if shuffle else "without_shuffle", 'seed_iv', epochs, batch_size)
print("starting subject-dependent training experiments on individual %d in session %d"% (idx, session))
elif mode == 'subject_independent':
train_X = np.vstack([np.vstack((e[0][0], e[1][0])) for i, e in enumerate(all_individual_data) if i != idx-1])
train_Y = np.hstack([np.hstack((e[0][1], e[1][1])) for i, e in enumerate(all_individual_data) if i != idx-1])
test_X = np.vstack((all_individual_data[idx-1][0][0], all_individual_data[idx-1][1][0]))
test_Y = np.hstack((all_individual_data[idx-1][0][1], all_individual_data[idx-1][1][1]))
exp_des = "%d_independent_as_testset_in_seesion_%d_%s_%s_%s_%d_%d" % (
idx, session, 'balance' if balance else 'without_balance',
'shuffle' if shuffle else "without_shuffle", 'seed_iv', epochs, batch_size)
print("starting subject-independent training experiments with individual %d in session %d as test set" % (idx, session))
else:
raise ValueError
print("train_X shape", train_X.shape)
print("train_Y shape", train_Y.shape)
print("test_X shape", test_X.shape)
print("test_Y shape", test_Y.shape)
train_loader = DataLoader(dataset=SEED_IV_DATASET(train_X, train_Y), batch_size=batch_size, shuffle=shuffle,
num_workers=4)
test_loader = DataLoader(dataset=SEED_IV_DATASET(test_X, test_Y), batch_size=batch_size, shuffle=shuffle,
num_workers=4)
print("model construction...")
net = SimpleDNN(num_layers=4, hidden_size=256, drop=0.5)
net = net.to(device)
optimization = Adam(net.parameters(), lr=learning_rate)
save_model_path = '../../saved_models/%s/session_%d/subject_%d_as_testset' % (
net.__class__.__name__, session,
idx) if mode == 'subject_independent' else '../../saved_models/%s/session_%d/_subject%d' % (
net.__class__.__name__, session, idx)
if not os.path.exists(save_model_path):
os.makedirs(save_model_path)
# save model training state
running_loss_list = []
running_acc_list = []
testing_loss_list =[]
testing_acc_list = []
best_acc = -1
print("start training...")
for epoch in range(epochs):
net.train()
running_loss = 0.0
correct = 0.0
total = 0.0
for i, (feature, target) in enumerate(train_loader):
optimization.zero_grad()
feature = feature.to(device)
target = target.type(torch.LongTensor).to(device)
out = net(feature)
loss = criterion(out, target)
loss.backward()
optimization.step()
running_loss += loss.item()
_, prediction = torch.max(out.data, dim=-1)
total += target.size(0)
correct += prediction.eq(target.data).cpu().sum()
cur_loss = running_loss / len(train_loader)
cur_acc = correct / total
if isinstance(cur_acc, torch.Tensor):
cur_acc = cur_acc.item()
if isinstance(cur_loss, torch.Tensor):
cur_loss = cur_loss.item()
print('Loss: %.10f | Acc: %.3f%% (%d/%d)' % (
cur_loss, 100 * cur_acc, correct, total))
running_loss_list.append(cur_loss)
running_acc_list.append(cur_acc)
if epoch % 1 == 0:
net.eval()
print("start evaluating...")
testing_loss = 0.0
test_correct = 0.0
test_total = 0.0
for i, (feature, target) in enumerate(test_loader):
feature = feature.to(device)
target = target.type(torch.LongTensor).to(device)
with torch.no_grad():
out = net(feature)
loss = criterion(out, target)
testing_loss += loss.item()
_, prediction = torch.max(out.data, dim=-1)
# print(prediction)
test_total += target.size(0)
test_correct += prediction.eq(target.data).cpu().sum()
test_acc = test_correct / test_total
test_loss = testing_loss / len(test_loader)
if isinstance(test_acc, torch.Tensor):
test_acc = test_acc.item()
if isinstance(test_loss, torch.Tensor):
test_loss = test_loss.item()
print('Testset Loss: %.10f | Acc: %.3f%% (%d/%d)' % (
test_loss, 100 * test_acc, test_correct, test_total))
testing_acc_list.append(test_acc)
testing_loss_list.append(test_loss)
if test_acc > best_acc:
best_acc = test_acc
print("better model founded in testsets, start saving new model")
model_name = '%s_%s' % (net.__class__.__name__, str(best_acc)[2:6])
state = {
'net': net.state_dict(),
'epoch': epoch,
'best_acc': best_acc,
'current_loss': test_loss
}
torch.save(state, os.path.join(save_model_path, model_name))
plot_acc_loss_curve({'train_loss': running_loss_list,
'train_acc': running_acc_list,
'test_loss': testing_loss_list,
'test_acc': testing_acc_list}, net.__class__.__name__, exp_des)
def subject_dependent(individual=1, class_target=4):
class_list = [
"Valence", "Arousal", "Dominance", "Liking", "Valence-Arousal"
]
class_nums = [2, 2, 2, 2, 4]
test_loss_list = [] # 记录每一折验证的loss
test_acc_list = [] # 记录每一折验证的acc
# prepare data
nor_method = 1
label_smooth = 0.1
shuffle = True
# reading the data in the whole dataset
deap = DEAP(individual=individual, normalization=nor_method)
train_X, train_Y = deap.get_train_data()
validate_X, validate_Y = deap.get_validate_data()
test_X, test_Y = deap.get_test_data()
# Hyper-parameters
epochs = 150
batch_size = 512
learning_rate = 1e-3
criterion = LabelSmoothSoftmax(lb_smooth=label_smooth)
#criterion_attn = CrossEntropyLoss()
print(
"starting subject-dependent training experiments on individual %d class %s"
% (individual, class_list[class_target]))
print("train_X shape", train_X.shape)
print("train_Y shape", train_Y.shape)
print("validate_X shape", validate_X.shape)
print("validate_Y shape", validate_Y.shape)
print("test_X shape", test_X.shape)
print("test_Y shape", test_Y.shape)
train_Y, test_Y, validate_Y = train_Y[:, class_target].squeeze(
), test_Y[:, class_target].squeeze(), validate_Y[:,
class_target].squeeze()
train_loader = DataLoader(dataset=DEAP_DATASET(train_X, train_Y),
batch_size=batch_size,
shuffle=shuffle,
num_workers=0)
validate_loader = DataLoader(dataset=DEAP_DATASET(validate_X, validate_Y),
batch_size=batch_size,
shuffle=shuffle,
num_workers=0)
test_loader = DataLoader(dataset=DEAP_DATASET(test_X, test_Y),
batch_size=batch_size,
shuffle=shuffle,
num_workers=0)
exp_des = "%d_dependent_%s_%s_%d_%d_%s" % (
individual, 'shuffle' if shuffle else "without_shuffle", 'deap',
epochs, batch_size, class_list[class_target])
print("model construction...")
net = SimpleDNN(num_layers=3,
input_size=200,
output_size=class_nums[class_target])
# if fine_tuning we continue train the pretrained model
net = net.to(device)
save_model_path = '../../saved_models/%s/deap/subject_%d/%s/' % (
net.__class__.__name__, individual, class_list[class_target])
if not os.path.exists(save_model_path):
os.makedirs(save_model_path)
optimization = Adam(net.parameters(), lr=learning_rate, weight_decay=0.001)
# save model training state
running_loss_list = []
running_acc_list = []
validate_loss_list = []
validate_acc_list = []
best_acc = -1
print("start training...")
scheduler_cosine = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer=optimization, T_max=epochs)
scheduler_warmup = GradualWarmupScheduler(optimizer=optimization,
multiplier=10,
total_epoch=np.ceil(0.1 *
epochs),
after_scheduler=scheduler_cosine)
for epoch in range(epochs):
net.train()
running_loss = 0.0
correct = 0.0
total = 0.0
for i, (feature, target) in enumerate(train_loader):
feature = feature.reshape(-1, 200)
optimization.zero_grad()
# print("脏数据统计", torch.sum(torch.isnan(feature), dim=0))
feature = feature.to(device)
target = target.type(torch.LongTensor).to(device)
out = net(feature)
# print("训练集", out.data[:5])
# print("训练集",eeg_attn.shape, eeg_attn.data[:5])
# print("训练集",eye_attn.shape, eye_attn.data[:5])
# print("batch output",out[0])
cross_entropy_loss = criterion(out, target)
# eeg_attn_loss = criterion_attn(eeg_attn, target)
# eye_attn_loss = criterion_attn(eye_attn, target)
# loss = cross_entropy_loss
# print("交叉熵损失", cross_entropy_loss.data)
# print("eeg注意力损失", eeg_attn_loss.data)
# print("eye注意力损失", eeg_attn_loss.data)
cross_entropy_loss.backward()
clip_grad_norm_(net.parameters(), max_norm=10)
# for name, parms in net.named_parameters():
# print('打印梯度')
# print('-->name:', name, '-->grad_requirs:', parms.requires_grad, \
# ' -->grad_value:', parms.grad)
optimization.step()
running_loss += cross_entropy_loss.item()
# print("batch loss", loss.item())
_, prediction = torch.max(out.data, dim=-1)
# print('训练集', prediction[:5])
total += target.size(0)
correct += prediction.eq(target.data).cpu().sum().item()
cur_loss = running_loss / total
cur_acc = correct / total
# print(cur_acc, correct, total)
if isinstance(cur_acc, torch.Tensor):
cur_acc = cur_acc.item()
if isinstance(cur_loss, torch.Tensor):
cur_loss = cur_loss.item()
print('Training Loss: %.10f | Training Acc: %.3f%% (%d/%d)' %
(cur_loss, 100 * cur_acc, correct, total))
running_loss_list.append(cur_loss)
running_acc_list.append(cur_acc)
scheduler_warmup.step()
if epoch % 1 == 0:
net.eval()
print("start evaluating...")
validate_loss = 0.0
validate_correct = 0.0
validate_total = 0.0
for i, (feature, target) in enumerate(validate_loader):
feature = feature.reshape(-1, 200)
feature = feature.to(device)
target = target.type(torch.LongTensor).to(device)
with torch.no_grad():
out = net(feature)
# print("c集", out.data[:5])
# print("c集", eeg_attn.data[:5])
# print("c集", eye_attn.data[:5])
loss = criterion(out, target)
validate_loss += loss.item()
_, prediction = torch.max(out.data, dim=-1)
# print('验证集',prediction[:5])
validate_total += target.size(0)
validate_correct += prediction.eq(
target.data).cpu().sum().item()
validate_acc = validate_correct / validate_total
validate_loss = validate_loss / validate_total
if isinstance(validate_acc, torch.Tensor):
validate_acc = validate_acc.item()
if isinstance(validate_loss, torch.Tensor):
validate_loss = validate_loss.item()
print('Validate Loss: %.10f | Validate-Acc: %.3f%% (%d/%d)' %
(validate_loss, 100 * validate_acc, validate_correct,
validate_total))
validate_acc_list.append(validate_acc)
validate_loss_list.append(validate_loss)
if validate_acc > best_acc:
best_acc = validate_acc
print(
"better model founded in testsets, start saving new model")
model_name = '%s' % (net.__class__.__name__)
state = {
'net': net.state_dict(),
'epoch': epoch,
'best_acc': best_acc,
'current_loss': validate_loss
}
torch.save(state, os.path.join(save_model_path, model_name))
# 开始计算测试集
checkpoint = torch.load(
os.path.join(save_model_path, net.__class__.__name__))
net.load_state_dict(checkpoint['net'])
print("start evaluating...")
testing_loss = 0.0
test_correct = 0.0
test_total = 0.0
for i, (feature, target) in enumerate(test_loader):
feature = feature.reshape(-1, 200)
feature = feature.to(device)
target = target.type(torch.LongTensor).to(device)
with torch.no_grad():
out = net(feature)
loss = criterion(out, target)
testing_loss += loss.item()
_, prediction = torch.max(out.data, dim=-1)
# print(prediction)
test_total += target.size(0)
test_correct += prediction.eq(target.data).cpu().sum().item()
test_acc = test_correct / test_total
test_loss = testing_loss / test_total
if isinstance(test_acc, torch.Tensor):
test_acc = test_acc.item()
if isinstance(test_loss, torch.Tensor):
test_loss = test_loss.item()
print('Test Loss: %.10f | Test Acc: %.3f%% (%d/%d)' %
(test_loss, 100 * test_acc, test_correct, test_total))
test_acc_list.append(test_acc)
test_loss_list.append(test_loss)
plot_acc_loss_curve(
{
'train_loss': running_loss_list,
'train_acc': running_acc_list,
'test_loss': validate_loss_list,
'test_acc': validate_acc_list
}, net.__class__.__name__, exp_des)
pd.DataFrame.from_dict({
'test_loss': test_loss_list,
'test_acc': test_acc_list
}).to_csv('./results/deap_individual_%d_%s.csv' %
(individual, class_list[class_target]),
mode='w',
index=False,
header=True,
encoding='utf-8')
def subject_dependent_CV(session=1):
# prepare data
session = session
balance = True
shuffle = False
modal = 'concat'
nor_method = 1
label_smooth = 0.3
fine_tuning = True
best_acc_list = []
best_precision_list = []
best_recall_list = []
best_f1_list = []
result_save_path = './seed_cv_results/session{}'.format(session)
if not os.path.exists(result_save_path):
os.makedirs(result_save_path)
# reading the data in the whole dataset
for idx in range(1, 16):
print("contructing dataset...")
eeg = SEED_IV(session=session,
individual=idx,
modal=modal,
shuffle=shuffle,
balance=balance,
k_fold=3)
k_fold_data = eeg.get_training_kfold_data()
for fold, (train_X, train_Y, test_X, test_Y) in enumerate(k_fold_data):
best_acc = -1
best_precision = -1
best_recall = -1
best_f1 = -1
print("train_X shape", train_X.shape)
print("train_Y shape", train_Y.shape)
print("test_X shape", test_X.shape)
print("test_Y shape", test_Y.shape)
train_X, train_Y, test_X, test_Y = seed_normalization(train_X,
train_Y,
test_X,
test_Y,
nor_method=1,
merge=0,
column=0)
train_X = train_X.astype(np.float32)
test_X = test_X.astype(np.float32)
train_Y = train_Y.astype(np.int32)
test_Y = test_Y.astype(np.int32)
# Hyper-parameters
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
epochs = 500
batch_size = 1024
learning_rate = 1e-4
criterion = LabelSmoothSoftmax(lb_smooth=label_smooth)
exp_des = "%d_dependent_in_seesion_%d_fold%d_%s_%s_%s_%d_%d" % (
idx, session, fold,
'balance' if balance else 'without_balance', 'shuffle'
if shuffle else "without_shuffle", 'seed', epochs, batch_size)
print(
"starting subject-dependent training experiments on individual %d in session %d"
% (idx, session))
print("train_X shape", train_X.shape)
print("train_Y shape", train_Y.shape)
print("test_X shape", test_X.shape)
print("test_Y shape", test_Y.shape)
print("model construction...")
net = Hierarchical_ATTN_With_Senti_Map()
# if fine_tuning we continue train the pretrained model
net = net.to(device)
save_model_path = '../../saved_models/%s/session_%d/subject_%d/fold_%d' % (
net.__class__.__name__, session, idx, fold)
if not os.path.exists(save_model_path):
os.makedirs(save_model_path)
optimization = RMSprop(net.parameters(),
lr=learning_rate,
weight_decay=0.01)
# save model training state
running_loss_list = []
running_acc_list = []
testing_loss_list = []
testing_acc_list = []
print("start training...")
scheduler_cosine = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer=optimization, T_max=epochs)
scheduler_warmup = GradualWarmupScheduler(
optimizer=optimization,
multiplier=10,
total_epoch=np.ceil(0.1 * epochs),
after_scheduler=scheduler_cosine)
for epoch in range(epochs):
net.train()
optimization.zero_grad()
#print("脏数据统计", torch.sum(torch.isnan(feature), dim=0))
eeg = train_X[:, :310]
eye = train_X[:, 310:]
eeg = eeg.reshape(-1, 62, 5)
eeg = torch.FloatTensor(eeg).to(device)
eye = torch.FloatTensor(eye).to(device)
#print("eeg type {}, eye type {}".format(type(eeg),type(eye)))
target = torch.LongTensor(train_Y).to(device)
out = net(eeg, eye)
#print("batch output",out[0])
loss = criterion(out, target)
loss.backward()
clip_grad_norm_(net.parameters(), max_norm=10)
optimization.step()
scheduler_warmup.step()
running_loss = loss.item()
#print("batch loss", loss.item())
_, prediction = torch.max(out.data, dim=-1)
total = target.size(0)
correct = prediction.eq(target.data).cpu().sum().item()
cur_loss = running_loss / len(train_X)
cur_acc = correct / total
if isinstance(cur_acc, torch.Tensor):
cur_acc = cur_acc.item()
if isinstance(cur_loss, torch.Tensor):
cur_loss = cur_loss.item()
print(
'Epoch %d/%d\tTraining Loss: %.10f | Acc: %.3f%% (%d/%d)' %
(epoch, epochs, cur_loss, 100 * cur_acc, correct, total))
running_loss_list.append(cur_loss)
running_acc_list.append(cur_acc)
if epoch % 1 == 0:
net.eval()
print("start evaluating...")
eeg = test_X[:, :310]
eye = test_X[:, 310:]
eeg = eeg.reshape(-1, 62, 5)
eeg = torch.FloatTensor(eeg).to(device)
eye = torch.FloatTensor(eye).to(device)
target = torch.LongTensor(test_Y).to(device)
with torch.no_grad():
out = net(eeg, eye)
loss = criterion(out, target)
testing_loss = loss.item()
_, prediction = torch.max(out.data, dim=-1)
# print(prediction)
test_total = target.size(0)
test_correct = prediction.eq(
target.data).cpu().sum().item()
y_pre = prediction.cpu().numpy()
y_true = target.cpu().numpy()
test_acc = accuracy_score(y_true, y_pre)
test_loss = testing_loss / test_total
if isinstance(test_acc, torch.Tensor):
test_acc = test_acc.item()
if isinstance(test_loss, torch.Tensor):
test_loss = test_loss.item()
print('Testset Loss: %.10f | Acc: %.3f%% (%d/%d)' %
(test_loss, 100 * test_acc, test_correct,
test_total))
testing_acc_list.append(test_acc)
testing_loss_list.append(test_loss)
if test_acc > best_acc:
best_acc = test_acc
best_precision = precision_score(y_true,
y_pre,
average="macro")
best_recall = precision_score(y_true,
y_pre,
average="macro")
best_f1 = f1_score(y_true, y_pre, average="macro")
print(
"better model founded in testsets, start saving new model"
)
model_name = '%s' % (net.__class__.__name__)
state = {
'net': net.state_dict(),
'epoch': epoch,
'best_acc': best_acc,
'current_loss': test_loss
}
torch.save(
state, os.path.join(save_model_path,
model_name))
best_f1_list.append(best_f1)
best_acc_list.append(best_acc)
best_precision_list.append(best_precision)
best_recall_list.append(best_recall)
plot_acc_loss_curve(
{
'train_loss': running_loss_list,
'train_acc': running_acc_list,
'test_loss': testing_loss_list,
'test_acc': testing_acc_list
}, net.__class__.__name__, exp_des)
df = pd.DataFrame().from_dict({
"acc": best_acc_list,
"precision": best_precision_list,
"recall": best_recall_list,
"f1": best_f1_list
})
df_mean = df.mean()
df_std = df.std()
df = df.append(df_mean, ignore_index=True)
df = df.append(df_std, ignore_index=True)
df.to_csv(result_save_path + '/results.csv')
def main(session=1, mode='subject_dependent'):
os.environ['CUDA_VISIBLE_DEVICES'] = '2'
# prepare data
session = session
balance = False
shuffle = False
modal = 'concat'
nor_method = 1
label_smooth = 0.1
fine_tuning = True
# reading the data in the whole dataset
all_individual_data = []
for i in range(1, 16):
print("contructing dataset...")
eeg = SEED_IV(session=session,
individual=i,
modal=modal,
shuffle=shuffle,
balance=balance,
normalization=nor_method)
_train_X, _train_Y = eeg.get_train_data()
_test_X, _test_Y = eeg.get_test_data()
all_individual_data.append([(_train_X, _train_Y), (_test_X, _test_Y)])
# Hyper-parameters
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
epochs = 120
batch_size = 128
learning_rate = 1e-3
criterion = LabelSmoothSoftmax(lb_smooth=label_smooth)
for idx in range(1, 16):
if mode == 'subject_dependent':
train_X, train_Y = all_individual_data[
idx - 1][0][0], all_individual_data[idx - 1][0][1]
test_X, test_Y = all_individual_data[
idx - 1][1][0], all_individual_data[idx - 1][1][1]
exp_des = "%d_dependent_in_seesion_%d_%s_%s_%s_%d_%d" % (
idx, session, 'balance' if balance else 'without_balance',
'shuffle' if shuffle else "without_shuffle", 'seed', epochs,
batch_size)
print(
"starting subject-dependent training experiments on individual %d in session %d"
% (idx, session))
elif mode == 'subject_independent':
train_X = np.vstack([
np.vstack((e[0][0], e[1][0]))
for i, e in enumerate(all_individual_data) if i != idx - 1
])
train_Y = np.hstack([
np.hstack((e[0][1], e[1][1]))
for i, e in enumerate(all_individual_data) if i != idx - 1
])
test_X = np.vstack((all_individual_data[idx - 1][0][0],
all_individual_data[idx - 1][1][0]))
test_Y = np.hstack((all_individual_data[idx - 1][0][1],
all_individual_data[idx - 1][1][1]))
exp_des = "%d_independent_as_testset_in_seesion_%d_%s_%s_%s_%d_%d" % (
idx, session, 'balance' if balance else 'without_balance',
'shuffle' if shuffle else "without_shuffle", 'seed', epochs,
batch_size)
print(
"starting subject-independent training experiments with individual %d in session %d as test set"
% (idx, session))
else:
raise ValueError
print("train_X shape", train_X.shape)
print("train_Y shape", train_Y.shape)
print("test_X shape", test_X.shape)
print("test_Y shape", test_Y.shape)
train_loader = DataLoader(dataset=SEED_IV_DATASET(train_X, train_Y),
batch_size=batch_size,
shuffle=shuffle,
num_workers=4)
test_loader = DataLoader(dataset=SEED_IV_DATASET(test_X, test_Y),
batch_size=batch_size,
shuffle=shuffle,
num_workers=4)
print("model construction...")
net = Hierarchical_ATTN()
# if fine_tuning we continue train the pretrained model
if mode == 'subject_dependent' and fine_tuning:
load_path = "../../saved_models/%s/session_%d/subject_%d_as_testset" % (
net.__class__.__name__, session, idx)
files = os.listdir(load_path)
best_model = max(files)
checkpoint = torch.load(os.path.join(load_path, best_model))
net.load_state_dict(checkpoint['net'])
learning_rate = 1e-5
batch_size = train_X.shape[0]
net = net.to(device)
save_model_path = '../../saved_models/%s/session_%d/subject_%d_as_testset' % (
net.__class__.__name__, session, idx
) if mode == 'subject_independent' else '../../saved_models/%s/session_%d/subject_%d' % (
net.__class__.__name__, session, idx)
if not os.path.exists(save_model_path):
os.makedirs(save_model_path)
optimization = Adam(net.parameters(),
lr=learning_rate,
weight_decay=0.001)
# save model training state
running_loss_list = []
running_acc_list = []
testing_loss_list = []
testing_acc_list = []
best_acc = -1
print("start training...")
scheduler_cosine = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer=optimization, T_max=epochs)
scheduler_warmup = GradualWarmupScheduler(
optimizer=optimization,
multiplier=10,
total_epoch=np.ceil(0.1 * epochs),
after_scheduler=scheduler_cosine)
for epoch in range(epochs):
net.train()
running_loss = 0.0
correct = 0.0
total = 0.0
for i, (feature, target) in enumerate(train_loader):
optimization.zero_grad()
#print("脏数据统计", torch.sum(torch.isnan(feature), dim=0))
eeg = feature[:, :310]
eye = feature[:, 310:]
eeg = eeg.reshape(-1, 62, 5)
eeg = eeg.to(device)
eye = eye.to(device)
target = target.type(torch.LongTensor).to(device)
out = net(eeg, eye)
#print("batch output",out[0])
cross_entropy_loss = criterion(out, target)
cross_entropy_loss.backward()
clip_grad_norm_(net.parameters(), max_norm=10)
optimization.step()
running_loss += cross_entropy_loss.item()
#print("batch loss", loss.item())
_, prediction = torch.max(out.data, dim=-1)
total += target.size(0)
correct += prediction.eq(target.data).cpu().sum()
cur_loss = running_loss / len(train_loader)
cur_acc = correct / total
if isinstance(cur_acc, torch.Tensor):
cur_acc = cur_acc.item()
if isinstance(cur_loss, torch.Tensor):
cur_loss = cur_loss.item()
print('Loss: %.10f | Acc: %.3f%% (%d/%d)' %
(cur_loss, 100 * cur_acc, correct, total))
running_loss_list.append(cur_loss)
running_acc_list.append(cur_acc)
scheduler_warmup.step()
if epoch % 1 == 0:
net.eval()
print("start evaluating...")
testing_loss = 0.0
test_correct = 0.0
test_total = 0.0
for i, (feature, target) in enumerate(test_loader):
eeg = feature[:, :310]
eye = feature[:, 310:]
eeg = eeg.reshape(-1, 62, 5)
eeg = eeg.to(device)
eye = eye.to(device)
target = target.type(torch.LongTensor).to(device)
with torch.no_grad():
out = net(eeg, eye)
loss = criterion(out, target)
testing_loss += loss.item()
_, prediction = torch.max(out.data, dim=-1)
# print(prediction)
test_total += target.size(0)
test_correct += prediction.eq(target.data).cpu().sum()
test_acc = test_correct / test_total
test_loss = testing_loss / len(test_loader)
if isinstance(test_acc, torch.Tensor):
test_acc = test_acc.item()
if isinstance(test_loss, torch.Tensor):
test_loss = test_loss.item()
print('Testset Loss: %.10f | Acc: %.3f%% (%d/%d)' %
(test_loss, 100 * test_acc, test_correct, test_total))
testing_acc_list.append(test_acc)
testing_loss_list.append(test_loss)
if test_acc > best_acc:
best_acc = test_acc
print(
"better model founded in testsets, start saving new model"
)
model_name = '%s_%s' % (net.__class__.__name__,
str(best_acc)[2:6])
state = {
'net': net.state_dict(),
'epoch': epoch,
'best_acc': best_acc,
'current_loss': test_loss
}
torch.save(state, os.path.join(save_model_path,
model_name))
plot_acc_loss_curve(
{
'train_loss': running_loss_list,
'train_acc': running_acc_list,
'test_loss': testing_loss_list,
'test_acc': testing_acc_list
}, net.__class__.__name__, exp_des)