def Test_model(Run, act, batch_size, Learning_rate):
Options = {'data_path': '../lab2', 'model': ['EEGNet', 'DeepConvNet']}
if (Run == 'EEGNet'):
model_name = Run
activation = act
model = EEGNet(activation).cpu()
else:
model_name = Run
activation = act
model = DeepConvNet(activation).cpu()
Path = './' + model_name
os.chdir(Path)
PATH = model_name + '_' + activation + '.pkl' #'.pt'
model.load_state_dict(torch.load(PATH))
model.eval()
# Hyper Parameter setting
Batch_size = batch_size
lr = Learning_rate
loss = nn.CrossEntropyLoss()
train_loader, test_loader, train_size, test_size = dataloader.read_bci_data(
Options['data_path'], Batch_size)
# Testing
test_acc = 0.0
test_loss = 0.0
model.eval()
for i, data in enumerate(test_loader):
test_pred = model(data[0].cpu())
batch_loss = loss(test_pred, data[1].cpu())
test_acc += np.sum(
np.argmax(test_pred.cpu().data.numpy(), axis=1) == data[1].numpy())
test_loss += batch_loss.item()
test_acc = test_acc / test_size * 100.0
print('Test Accuracy : {:.2f}%'.format(test_acc))
def iter_test_act(model_func):
act_map = {
'Relu': torch.nn.ReLU,
'Leaky_relu': torch.nn.LeakyReLU,
'Elu': torch.nn.ELU
}
max_epoch = 300
# Load data
t_data, t_lbl, v_data, v_lbl = dataloader.read_bci_data('./dataset')
# Loss function
criterion = torch.nn.CrossEntropyLoss()
# Recorder of train & val for different activation
act_rec = dict()
# Load model
for name, act in act_map.items():
print('-' * 77)
print(f"[ INFO ]Testing activation function: {name}")
model = model_func(activation=act)
model.to('cuda:0')
# Optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
act_rec[name] = train_val(model, criterion, optimizer, max_epoch,
t_data, t_lbl, v_data, v_lbl)
return act_rec
def main():
import dataloader
model = EEGNet()
model.eval()
print(model)
data, _, _, _ = dataloader.read_bci_data('./dataset')
x = torch.Tensor(data[0:1])
print(model(x))
def get_bci_dataloaders():
train_x, train_y, test_x, test_y = read_bci_data()
datasets = []
for train, test in [(train_x, train_y), (test_x, test_y)]:
train = torch.stack(
[torch.Tensor(train[i]) for i in range(train.shape[0])])
test = torch.stack(
[torch.Tensor(test[i:i + 1]) for i in range(test.shape[0])])
datasets += [TensorDataset(train, test)]
return datasets
def eval_model(model_func):
act_map = {
'Relu': torch.nn.ReLU,
'Leaky_relu': torch.nn.LeakyReLU,
'Elu': torch.nn.ELU
}
# Load data
t_data, t_lbl, v_data, v_lbl = dataloader.read_bci_data('./dataset')
# Load model
for name, act in act_map.items():
model = model_func(activation=act)
try:
weight = torch.load('./weights/' + model.name + model.act_name +
'.pt')
except FileNotFoundError:
print(f'You have not saved weights for {model.name}')
sys.exit()
model.load_state_dict(weight)
model.to('cuda:0')
# Test
model.eval()
_, val_acc = inference(model, v_data, v_lbl)
print(f"{name}: validation accuracy: {val_acc:.2%}")
)
self.classify = nn.Sequential(
nn.Linear(in_features=736, out_features=2, bias=True))
def forward(self, x):
x = self.firstconv(x)
x = self.depthwiseConv(x)
x = self.separableConv(x)
x = x.view(-1, 32 * 23)
x = self.classify(x)
return x
if __name__ == '__main__':
X_train, y_train, X_test, y_test = dataloader.read_bci_data()
print("Training data: ", X_train.shape)
print("Training label: ", y_train.shape)
print("Testing data: ", X_test.shape)
print("Testing label: ", y_test.shape)
print("-" * 50)
train = LoadData(X_train, y_train)
train_loader = torch.utils.data.DataLoader(
train,
batch_size=64,
shuffle=False,
drop_last=False,
pin_memory=True,
)
test = LoadData(X_test, y_test)
plt.show()
def gen_dataset(train_x, train_y, test_x, test_y):
datasets = []
for x, y in [(train_x, train_y), (test_x, test_y)]:
x = torch.stack(
[torch.Tensor(x[i]) for i in range(x.shape[0])]
)
y = torch.stack(
[torch.Tensor(y[i:i+1]) for i in range(y.shape[0])]
)
datasets += [TensorDataset(x, y)]
return datasets
train_dataset, test_dataset = gen_dataset(*dataloader.read_bci_data())
class EEGNet(nn.Module):
def __init__(self, activation=None, dropout=0.25):
super(EEGNet, self).__init__()
if not activation:
activation = nn.ELU
self.firstconv = nn.Sequential(
nn.Conv2d(
1, 16, kernel_size=(1, 51),
stride=(1,1), padding=(0,25), bias=False
),
nn.BatchNorm2d(16)
)
def main(args):
train_x, train_y, test_x, test_y = read_bci_data()
torch_dataset = Data.TensorDataset(
torch.from_numpy(train_x.astype(np.float32)),
torch.from_numpy(train_y.astype(np.float32)))
train_loader = Data.DataLoader(dataset=torch_dataset,
batch_size=args.batch,
shuffle=True)
net_dict = choose_net(args)
model_fullname = {'eeg': 'EEGNet', 'dcn': 'DeepConvNet'}
acc_dict = {}
if args.load:
net_dict['relu'][0].load_state_dict(torch.load(args.load))
net_dict['relu'][0].eval()
test_accuracy = cal_accuracy(net_dict['relu'][0], test_x, test_y)
print('test_acc: {:.4f}%'.format(test_accuracy * 100))
return
# net[0]: model, net[1]: optimizer, net[2]: loss_function
for key, net in net_dict.items():
acc_dict['train_{}'.format(key)] = []
acc_dict['test_{}'.format(key)] = []
optimizer, loss_func = handle_param(args, net[0])
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[50, 150],
gamma=0.5)
net.extend([optimizer, loss_func, scheduler])
max_acc = 0
file_name = '{}_lr{}_ep{}'.format(args.model, args.learning_rate,
args.epochs)
# start training
for epoch in range(args.epochs):
print('-' * 10, 'epoch', epoch + 1, '-' * 10)
loss_dict = {}
for key in net_dict.keys():
loss_dict[key] = []
# training
for b_x, b_y in train_loader:
for key, net in net_dict.items():
# apply scheduler
net[3].step()
output = net[0](b_x)
loss = net[2](output, b_y.long())
loss_dict[key].append(loss.data.numpy())
net[1].zero_grad()
loss.backward()
net[1].step()
# show loss and accuracy
for key, net in net_dict.items():
net[0].eval()
train_accuracy = cal_accuracy(net[0], train_x, train_y)
test_accuracy = cal_accuracy(net[0], test_x, test_y)
if test_accuracy > max_acc:
max_acc = test_accuracy
torch.save(net[0].state_dict(), file_name + '.pkl')
acc_dict['train_{}'.format(key)].append(train_accuracy)
acc_dict['test_{}'.format(key)].append(test_accuracy)
print('---------- {} ({}) ----------'.format(
model_fullname[args.model], key))
print(
'training loss: {:.6f} | train_acc: {:.6f} | test_acc: {:.6f}'.
format(max(loss_dict[key]), train_accuracy, test_accuracy))
net[0].train()
print('max_acc: {}'.format(max_acc))
# save / show result
# show_result(range(args.epochs), acc_dict, 'EEG')
with open(file_name + '.json', 'w') as f:
json.dump(
{
'x': list(range(args.epochs)),
'y_dict': acc_dict,
'title': model_fullname[args.model],
},
f,
cls=NumpyEncoder)
self.label = torch.from_numpy(label).float()
def __getitem__(self, index):
return self.data[index], self.label[index]
def __len__(self):
return len(self.data)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
batch_size = 128
leanring_rate = 1e-3
epochs = 1000
train_data, train_label, test_data, test_label = dataloader.read_bci_data()
my_train_data = MyDataset(train_data, train_label)
my_test_data = MyDataset(test_data, test_label)
train_data_loader = torch.utils.data.DataLoader(my_train_data,
batch_size=batch_size,
shuffle=True)
test_data_loader = torch.utils.data.DataLoader(my_test_data,
batch_size=batch_size,
shuffle=True)
x_axis = [i + 1 for i in range(epochs)]
parser.add_argument('--epochs',
default=3000,
type=int,
help="number of total epochs to run")
parser.add_argument('--lr',
'--learning-rate',
default=1e-3,
type=float,
help="initial learning rate")
parser.add_argument('--checkpoint', type=str, help="name of checkpoint file")
args = parser.parse_args()
CHECKPOINT = args.checkpoint
# Prepare for data
train_X, train_y, test_X, test_y = dataloader.read_bci_data()
train_X = torch.from_numpy(train_X).float()
train_y = torch.from_numpy(np.array(train_y)).long()
test_X = torch.from_numpy(test_X).float()
test_y = torch.from_numpy(np.array(test_y)).long()
# DataLoader
train_dataset = TensorDataset(train_X, train_y)
train_dataloader = DataLoader(train_dataset, batch_size=args.batch_size)
# Construct desired model
model = None
if args.model == "EEGNet":
model = EEGNet(activation_function=args.activation_function)
elif args.model == "DeepConvNet":
model = DeepConvNet(activation_function=args.activation_function)
import numpy as np
# print(torch.cuda.is_available())
# hyper parameters
epochs = 2000
batch_size = 64
lr = 1e-2
activation_functions = {"ReLU":nn.ReLU(), "LeakyReLU":nn.LeakyReLU(), "ELU":nn.ELU()}
# history
acc_history = {"ReLU":{}, "LeakyReLU":{}, "ELU":{}}
best_test_acc = {"ReLU":0 , "LeakyReLU":0 , "ELU":0 }
# load data
train_X, train_Y, test_X, test_Y = read_bci_data()
train_data = DataLoader(list(zip(train_X, train_Y)), batch_size=batch_size, shuffle=True, num_workers=0)
test_data = DataLoader(list(zip(test_X, test_Y)) , batch_size=batch_size, shuffle=True, num_workers=0)
def evaluate(net, data):
acc_count = 0
data_count = 0
for idx, data_batch in enumerate(data):
inputs = data_batch[0].float().cuda(0)
labels = data_batch[1].long()
outputs = net(inputs)
predicts = np.argmax(outputs.cpu().detach().numpy(), axis = 1)
for idx in range(len(predicts)):
if predicts[idx] == labels[idx]:
acc_count +=1
data_count+=1
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data as utils
import matplotlib.pyplot as plt
import numpy as np
from dataloader import read_bci_data
train_data, train_label, test_data, test_label = read_bci_data()
CUDA = False
if torch.cuda.is_available():
device = torch.device("cuda")
CUDA = True
print("Cuda Available !")
tensor_train_data = torch.stack([torch.Tensor(i) for i in train_data]) # transform to torch tensors
tensor_train_label = torch.from_numpy(train_label)
dataset = utils.TensorDataset(tensor_train_data, tensor_train_label) # create your datset
dataloader = utils.DataLoader(dataset, batch_size=64, shuffle=True, num_workers=4) # create your dataloader
tensor_test_data = torch.stack([torch.Tensor(i) for i in test_data]) # transform to torch tensors
tensor_test_label = torch.from_numpy(test_label)
test_dataset = utils.TensorDataset(tensor_test_data, tensor_test_label) # create your datset
test_dataloader = utils.DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4) # create your dataloader
def Process(model, activation, batch_size, epoch, Learning_rate):
Options = {'data_path': './lab2', 'model': ['EEGNet', 'DeepConvNet']}
# Model initialization
Run = model #int(input())
if (Run == 'EEGNet'):
model_name = Options['model'][0]
activation_function = activation
model = EEGNet(activation_function)
model.cuda()
else:
model_name = Options['model'][1]
activation_function = activation
model = DeepConvNet(activation_function)
model.cuda()
# Hyper Parameter setting
Batch_size = batch_size
num_epochs = epoch
lr = Learning_rate
loss = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
# plot file setting
train_record = model_name + '_' + activation_function + '_train.csv'
test_record = model_name + '_' + activation_function + '_test.csv'
model_weight = model_name + '_' + activation_function + '.pkl' #'.pt'
print('Dealing with ' + train_record)
print('Dealing with ' + test_record)
# Read file, get the data which are wrapped into dataloader
train_loader, test_loader, train_size, test_size = dataloader.read_bci_data(
Options['data_path'], Batch_size)
os.chdir('../' + model_name)
# Training & Testing & 寫入檔案
with open(train_record, 'w', newline='') as csvfile:
write_train = csv.writer(csvfile)
with open(test_record, 'w', newline='') as csvFile:
write_test = csv.writer(csvFile)
for epoch in range(num_epochs):
# Training
train_acc = 0.0
train_loss = 0.0
model.train()
for i, data in enumerate(train_loader):
optimizer.zero_grad()
#Variable()
train_pred = model(data[0].cuda())
batch_loss = loss(train_pred, data[1].cuda())
batch_loss.backward()
optimizer.step()
train_acc += np.sum(
np.argmax(train_pred.cuda().data.numpy(), axis=1) ==
data[1].numpy())
train_loss += batch_loss.item()
train_acc = train_acc / train_size * 100.0
print('# {} epoch, Train Accuracy : {:.2f}%'.format(
epoch + 1, train_acc))
write_train.writerow([epoch, train_acc])
# Testing
test_acc = 0.0
test_loss = 0.0
model.eval()
for i, data in enumerate(test_loader):
test_pred = model(data[0].cuda())
batch_loss = loss(test_pred, data[1].cuda())
test_acc += np.sum(
np.argmax(test_pred.cuda().data.numpy(), axis=1) ==
data[1].numpy())
test_loss += batch_loss.item()
test_acc = test_acc / test_size * 100.0
print('# {} epoch, Test Accuracy : {:.2f}%'.format(
epoch + 1, test_acc))
write_test.writerow([epoch, test_acc])
torch.save(model.state_dict(), model_weight)
import argparse
import dataloader
import numpy as np
from EEGNet import EEGNet
# Argparse
parser = argparse.ArgumentParser(description=f'Runnning EEG Classification')
parser.add_argument('-a', '--activation-function', default="LeakyReLU", type=str, help="desired type of activation function")
parser.add_argument('-m', '--model', default="EEGNet", type=str, help="select model")
parser.add_argument('--checkpoint', default="./checkpoint/EEGNet_demo.pth", type=str, help="name of checkpoint file")
args = parser.parse_args()
# Prepare for data
_, _, test_X, test_y = dataloader.read_bci_data()
test_X = torch.from_numpy(test_X).float()
test_y = torch.from_numpy(np.array(test_y)).long()
# Select model
model = EEGNet(args.activation_function)
# go into evaluation mode (mainly for dropout & batch_normalization)
model.eval()
# Load weight file
model = model.cuda()
checkpoint = torch.load(args.checkpoint)
model.load_state_dict(checkpoint['state_dict'])
test_X = test_X.cuda()
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy: %f %%' % (100 * correct / total), comment)
return (100.0 * correct) / total
MAX_EPOCH = 100
LR = 0.01
#path = 'G:/VM_SYNC/Deeplearning/lab2'
#os.chdir('G:/VM_SYNC/Deeplearning/lab2')
device = torch.device('cpu')
a, b, c, d = dataloader.read_bci_data()
train_x = torch.tensor(a, dtype=torch.float, device=device)
train_y = torch.tensor(b, dtype=torch.long, device=device)
test_x = torch.tensor(c, dtype=torch.float, device=device)
test_y = torch.tensor(d, dtype=torch.long, device=device)
test_dataset = Data.TensorDataset(test_x, test_y)
test_loader = Data.DataLoader(dataset=test_dataset,
batch_size=1080,
shuffle=False,
num_workers=0)
#netA = DeepConvNet('ELU')
#netB = EGG('ELU')
#input()
if __name__ == '__main__':
# parameters
lr_step = 200
args, name = parser()
LR = args.lr
EPOCH = args.EPOCH
#BSIZE = args.BSIZE
BSIZE = 2000
GAMMA = args.GAMMA
MILESTONES = [int(ms) for ms in args.MILESTONES]
print(name)
device = torch.device(f'cuda:{args.gpu}')
# load data
tr_X, tr_y, ts_X, ts_y = read_bci_data()
tr_X, tr_y, ts_X, ts_y = torch.from_numpy(tr_X), torch.from_numpy(
tr_y), torch.from_numpy(ts_X), torch.from_numpy(ts_y)
train_dataloader = Data.DataLoader(Data.TensorDataset(tr_X, tr_y),
batch_size=BSIZE)
test_dataloader = Data.DataLoader(Data.TensorDataset(ts_X, ts_y),
batch_size=len(ts_y))
# model
loss_func = nn.CrossEntropyLoss()
if args.MODEL == 'EEG':
model = EEGNet(args.activate)
elif args.MODEL == 'deep':
model = DeepConvNet(args.activate)
model = model.to(device)
#print(model)
