def train_and_validate():
print('Seizure Detection Learning')
print('---------------------------------------------------------------')
do_train = True
ds_seizure = SeizureDataset(FLAGS)
if do_train:
X_train, y_train = ds_seizure.load_train_data(FLAGS.train_set)
print('Data sample size:', X_train[0].shape)
print('------------------------------------')
print('Batch size: ', FLAGS.batch_size)
print('------------------------------------')
# Note : Make sure dataset is divisible by batch_size
try:
assert(len(X_train) % FLAGS.batch_size == 0)
except:
print("Make sure dataset size is divisble by batch_size!")
sys.exit(1)
with tf.Graph().as_default():
# create and train the network
rnn_net = SeizureClassifier(FLAGS)
rnn_net.setup_loss()
rnn_net.do_train(ds_seizure, X_train, y_train, FLAGS)
#print('Final evaluation on the training data')
# print('---------------------------------------------------------------')
#rnn_net.do_eval(X_train, y_train)
# At this point we are done with the training data
del X_train
del y_train
print('Testing')
print('---------------------------------------------------------------')
X_test, ids = ds_seizure.load_test_data(FLAGS.test_set)
with tf.Graph().as_default():
# create and train the network
rnn_net = SeizureClassifier(FLAGS)
rnn_net.setup_loss()
predictions = rnn_net.predict(X_test, FLAGS)
# Save the results
frame = pd.DataFrame(
{'File': ids,
'Class': predictions
})
cols = frame.columns.tolist()
cols = cols[-1:] + cols[:-1]
frame = frame[cols]
frame['Class'] = frame['Class'].astype(float)
frame.to_csv(FLAGS.test_set + '_res.csv', index=False)
print('Saved results in: ', FLAGS.test_set)
def setUpClass(cls):
FLAGS = namedtuple('FLAGS',
'input_subsample_rate train_set test_set batch_size')
flags = FLAGS(160,
'train_1_dummy',
'test_1_dummy',
1)
cls.ds = SeizureDataset(flags)
def main(_):
username = os.getlogin()
user_dir = '/home/' + username
instances_count = 1
total_patient = 3
for patient in xrange(total_patient):
patient_id = 1 + patient
FLAGS.patient_id = patient_id
FLAGS.train_set = 'image_train_{0}_1000/single_side_fft/'.format(
patient_id)
FLAGS.test_set = 'image_test_{0}_1000/single_side_fft/'.format(
patient_id)
predictions = 0
for instances in xrange(instances_count):
ds_seizure = SeizureDataset(FLAGS)
X_train, y_train = ds_seizure.load_train_data(FLAGS.train_set)
X_test, y_ids = ds_seizure.load_test_data(FLAGS.test_set)
ds = NetworkDataset(X_train, y_train, X_test, y_ids)
FLAGS.model_dir = user_dir + '/seizure_models/single_side_fft/patient_{0}/model_{1}.cpkd'.format(
FLAGS.patient_id, instances)
predictions += np.array(train_and_validate(ds, instances))
store_total_avg_pred(ds, instances_count, predictions)
def main(args):
args = {
"model": "vqvae",
"batch_size": 16, # 7 * 9 = 63 (close to desired 64)
"hidden": 128,
"k": 512 * 2,
"lr": 2e-4,
"vq_coef": 1, # ?
"commit_coef": 1, # ?
"kl_coef": 1, # ?
"dataset": "imagenet",
"epochs": 25,
"cuda": torch.cuda.is_available(),
"seed": 1,
"gpus": "1",
"log_interval": 50,
"results_dir": "VAE_imagenet",
"save_name": "first",
"data_format": "json"
}
#
# parser = argparse.ArgumentParser(description='Variational AutoEncoders')
#
# model_parser = parser.add_argument_group('Model Parameters')
# model_parser.add_argument('--model', default='vae', choices=['vae', 'vqvae'],
# help='autoencoder variant to use: vae | vqvae')
# model_parser.add_argument('--batch-size', type=int, default=128, metavar='N',
# help='input batch size for training (default: 128)')
# model_parser.add_argument('--hidden', type=int, metavar='N',
# help='number of hidden channels')
# model_parser.add_argument('-k', '--dict-size', type=int, dest='k', metavar='K',
# help='number of atoms in dictionary')
# model_parser.add_argument('--lr', type=float, default=None,
# help='learning rate')
# model_parser.add_argument('--vq_coef', type=float, default=None,
# help='vq coefficient in loss')
# model_parser.add_argument('--commit_coef', type=float, default=None,
# help='commitment coefficient in loss')
# model_parser.add_argument('--kl_coef', type=float, default=None,
# help='kl-divergence coefficient in loss')
#
# training_parser = parser.add_argument_group('Training Parameters')
# training_parser.add_argument('--dataset', default='cifar10', choices=['mnist', 'cifar10', 'imagenet'],
# help='dataset to use: mnist | cifar10')
# training_parser.add_argument('--data-dir', default='/media/ssd/Datasets',
# help='directory containing the dataset')
# training_parser.add_argument('--epochs', type=int, default=20, metavar='N',
# help='number of epochs to train (default: 10)')
# training_parser.add_argument('--no-cuda', action='store_true', default=False,
# help='enables CUDA training')
# training_parser.add_argument('--seed', type=int, default=1, metavar='S',
# help='random seed (default: 1)')
# training_parser.add_argument('--gpus', default='0',
# help='gpus used for training - e.g 0,1,3')
#
# logging_parser = parser.add_argument_group('Logging Parameters')
# logging_parser.add_argument('--log-interval', type=int, default=10, metavar='N',
# help='how many batches to wait before logging training status')
# logging_parser.add_argument('--results-dir', metavar='RESULTS_DIR', default='./results',
# help='results dir')
# logging_parser.add_argument('--save-name', default='',
# help='saved folder')
# logging_parser.add_argument('--data-format', default='json',
# help='in which format to save the data')
# args = parser.parse_args(args)
# args["cuda"] = not args["no_cuda"] and torch.cuda.is_available()
lr = args["lr"] # or default_hyperparams[args["dataset"]]['lr']
k = args["k"] # or default_hyperparams[args["dataset"]]['k']
hidden = args["hidden"] or default_hyperparams[args["dataset"]]['hidden']
num_channels = dataset_sizes[args["dataset"]][0]
results, save_path = setup_logging_and_results(args)
torch.manual_seed(args["seed"])
if args["cuda"]:
torch.cuda.manual_seed_all(args["seed"])
args["gpus"] = [int(i) for i in args["gpus"].split(',')]
# torch.cuda.set_device(args["gpus"][0])
cudnn.benchmark = True
torch.cuda.manual_seed(args["seed"])
model = models[args["dataset"]][args["model"]](hidden, k=k, num_channels=num_channels)
#model = MyDataParallel(model)
print("Number of Parameters in Model:", sum(p.numel() for p in model.parameters() if p.requires_grad))
if args["cuda"]:
model.cuda()
optimizer = optim.Adam(model.parameters(), lr=lr)
scheduler = optim.lr_scheduler.StepLR(optimizer, 10 if args["dataset"] == 'imagenet' else 30, 0.5, )
kwargs = {'num_workers': 1, 'pin_memory': True} if args["cuda"] else {}
train_loader = torch.utils.data.DataLoader(
dataset=SeizureDataset(transform=dataset_transforms[args["dataset"]]),
shuffle=True,
batch_size=args["batch_size"],
# transform=dataset_transforms[args["dataset"]],
)
test_loader = torch.utils.data.DataLoader(
dataset=SeizureDataset(file_dir=DEV_SEIZURE_FILE, split="dev", transform=dataset_transforms[args["dataset"]]), # TODO: add test filename for dataset initialization
# transform=dataset_transforms[args["dataset"]],
# dataset=SeizureDataset(transform=dataset_transforms[args["dataset"]]),
batch_size=args["batch_size"],
shuffle=True
)
print("Save path", save_path)
for epoch in range(1, args["epochs"] + 1):
train_losses = train(epoch, model, train_loader, optimizer, args["cuda"], args["log_interval"], save_path, args)
test_losses = test_net(epoch, model, test_loader, args["cuda"], save_path, args)
results.add(epoch=epoch, **train_losses, **test_losses)
for k in train_losses:
key = k[:-6]
results.plot(x='epoch', y=[key + '_train', key + '_test'])
results.save()
scheduler.step()
torch.save(model.state_dict(), save_path + "/model" )
def train_and_validate():
height = 300
width = 300
depth = 16
output_dim = 1
patch_size_1 = 5
patch_size_2 = 5
feature_size_1 = 32
feature_size_2 = 64
fc_size = 1024
print('Seizure Detection Learning')
print('---------------------------------------------------------------')
do_train = True
ds_seizure = SeizureDataset(FLAGS)
if do_train:
X_train, y_train = ds_seizure.load_train_data(FLAGS.train_set)
train_set_size = int(round(FLAGS.train_ds_ratio * len(X_train)))
X_train_set = X_train[:train_set_size]
y_train_set = y_train[:train_set_size]
X_val_set = X_train[train_set_size:]
y_val_set = y_train[train_set_size:]
print('Data sample size = ', X_train[0].shape)
print('Trainig samples count = ', len(y_train_set))
print('Validation samples count = ', len(y_val_set))
print('------------------------------------')
print('Batch size: ', FLAGS.batch_size)
print('------------------------------------')
# Note : Make sure dataset is divisible by batch_size
# try:
# assert(len(X_train) % FLAGS.batch_size == 0)
# except:
# print("Make sure dataset size is divisble by batch_size!")
# sys.exit(1)
y_1s_train_cnt = np.sum(y_train_set)
y_0s_train_cnt = train_set_size - y_1s_train_cnt
FLAGS.pos_weight = (1. * y_0s_train_cnt) / y_1s_train_cnt
print('Positive weight = ', FLAGS.pos_weight)
with tf.Graph().as_default():
# create and train the network
cnn_net = SeizureClassifier(FLAGS, height, width, depth,
output_dim, patch_size_1, patch_size_2,
feature_size_1, feature_size_2,
fc_size)
cnn_net.setup_loss_and_trainOp(FLAGS)
cnn_net.do_train(ds_seizure, X_train_set, y_train_set, X_val_set,
y_val_set, FLAGS)
# Start a new graph
with tf.Graph().as_default():
cnn_net = SeizureClassifier(FLAGS, height, width, depth, output_dim,
patch_size_1, patch_size_2, feature_size_1,
feature_size_2, fc_size)
cnn_net.setup_loss_and_trainOp(FLAGS)
cnn_net.predict(ds_seizure, FLAGS)
import torch
import numpy as np
import sys
import time
from torch.utils.data import DataLoader
sys.path.append("../tsy935/RubinLab_neurotranslate_eeg-master/eeg/data/")
from torch import nn, optim
from torch.nn import functional as F
from torch.autograd import Variable
from features_to_features_model import FeaturesToFeatures
from data_loader import SeizureDataset
num_epochs = 100000
batch_size = 7 # 7 b/c 7 * 9 = 63
train_dataset = SeizureDataset()
print("len train", len(train_dataset))
train_loader = DataLoader(dataset=train_dataset,
shuffle=True,
batch_size=batch_size)
use_cuda = torch.cuda.is_available()
model = FeaturesToFeatures(pretrained_encoder=False)
test_num = 6
if use_cuda:
model.cuda()
optimizer = optim.Adam(model.parameters())