diff --git a/pytorch_implementation/.gitignore b/pytorch_implementation/.gitignore new file mode 100755 index 0000000..d01cf4a --- /dev/null +++ b/pytorch_implementation/.gitignore @@ -0,0 +1 @@ +logs/*.* diff --git a/pytorch_implementation/MLP.py b/pytorch_implementation/MLP.py new file mode 100755 index 0000000..df0c482 --- /dev/null +++ b/pytorch_implementation/MLP.py @@ -0,0 +1,111 @@ +import numpy as np +import sys, os, logging +import startup_header_code as startup +import torch +from torch.autograd import variable +import torch.nn.functional as F +import torch.nn as nn +import torch.utils.data + + +class MLP_autoencoder(nn.Module): + + def __init__(self, input_dimension): + super(MLP_autoencoder, self).__init__() + + # Input the layer definition + self.inp_dimen = input_dimension + self.h1_enc_size = 128 + self.h2_enc_size = 64 + self.h3_enc_size = 32 + + self.h3_dec_size = 32 + self.h2_dec_size = 64 + self.h1_dec_size = 128 + self.out_dim = input_dimension + + self.layer1 = nn.Linear(self.inp_dimen, self.h1_enc_size, bias = True) + self.layer2 = nn.Linear(self.h1_enc_size, self.h2_enc_size, bias = True) + self.layer3 = nn.Linear(self.h2_enc_size, self.h3_enc_size, bias = True) + + self.layer4 = nn.Linear(self.h3_enc_size, self.h3_dec_size, bias = True) + self.layer5 = nn.Linear(self.h3_dec_size, self.h2_dec_size, bias = True) + self.layer6 = nn.Linear(self.h2_dec_size, self.h1_dec_size, bias = True) + self.out_layer = nn.Linear(self.h1_dec_size, self.out_dim) + + def Encoder(self, x): + h1_out = F.reul(self.layer1(x)) + h2_out = F.relu(self.layer2(h1_out)) + h3_out = F.relu(self.layer3(h2_out)) + return h3_out + + def Decoder(self, encoded): + h4_out = F.relu(self.layer4(encoded)) + h5_out = F.relu(self.layer5(h4_out)) + h6_out = F.relu(self.layer6(h5_out)) + output = F.relu(self.out_layer(h6_out)) + return output + + + +params = startup.setup_data() +postGad_train_data = params['postGad_train_data'] +preGad_train_data = params['preGad_train_data'] +postGad_test_data = params['postGad_test_data'] +preGad_test_data = params['preGad_test_data'] +base_dir = params['base_dir'] +num_batches = params['num_batches'] +num_epochs = params['num_epochs'] +numVox = params['numVox'] +index_list = params['index_list'] +model_name = params['model_name'] +logfilename = params['logfilename'] +out_dir = params['out_dir'] +model_id = params['model_id'] +step_size = params['step_size'] +activation = params['activation'] +batch_size = params['batch_size'] +opt_flag = params['opt_flag'] + +learning_rate = step_size +momentum=0.9 + +data_dim = postGad_train_data.shape[1] + +mlp_net = MLP_autoencoder(data_dim) +criterion = nn.CrossEntropyLoss() +optimizer = torch.optim.SGD(mlp_net.parameters(), lr = learning_rate, momentum = momentum) + + +#Divide data in batches +train_data = torch.utils.data.TensorDataset(postGad_train_data, preGad_train_data) +test_data = torch.utils.data.TensorDataset(postGad_test_data, preGad_test_data) + +trainloader = torch.utils.data.DataLoader(postGad_train_data, preGad_train_data, batch_size = batch_size, shuffle = True, drop_last = False) +testloader = torch.utils.data.DataLoader(postGad_test_data, preGad_test_data, batch_size = batch_size, shuffle = True, drop_last = False) + + +## Training the network + +for epoch in range(num_epochs): + training_loss = 0.0 + startup = time.time() + + for i, data in enumerate(trainloader, 0): + # unpack the features and the labels + # train_labels + # train_data + + features_in, features_out = Variable(features_in), Variables(features_out) + optimizer.zero_grad() + + # feed forward the batch to network and compute the loss + output = mlp_net(features) + loss = criterion(output, features_out) + + # Compute the gradient and update weights + loss.backward() + optimizer.step() + print ('[epoch: %d] loss: %.3f, elapsed time: %.2f' (epoch+1, training_loss / (i+1), time.time() - starttime)) + + diff --git a/pytorch_implementation/MLP_v2.py b/pytorch_implementation/MLP_v2.py new file mode 100755 index 0000000..dd9d65c --- /dev/null +++ b/pytorch_implementation/MLP_v2.py @@ -0,0 +1,160 @@ +import numpy as np +import sys, os, logging +import startup_header_code as startup +import torch +from torch.autograd import Variable +import torch.nn.functional as F +import torch.nn as nn +import torch.utils.data +import time +import logging + +class MLP_autoencoder(nn.Module): + + def __init__(self, input_dimension): + super(MLP_autoencoder, self).__init__() + + # Input the layer definition + self.inp_dimen = input_dimension + self.h1_enc_size = 128 + self.h2_enc_size = 64 + self.h3_enc_size = 32 + + self.h3_dec_size = 32 + self.h2_dec_size = 64 + self.h1_dec_size = 128 + self.out_dim = input_dimension + + self.layer1 = nn.Linear(self.inp_dimen, self.h1_enc_size, bias = True) + self.layer2 = nn.Linear(self.h1_enc_size, self.h2_enc_size, bias = True) + self.layer3 = nn.Linear(self.h2_enc_size, self.h3_enc_size, bias = True) + + self.layer4 = nn.Linear(self.h3_enc_size, self.h3_dec_size, bias = True) + self.layer5 = nn.Linear(self.h3_dec_size, self.h2_dec_size, bias = True) + self.layer6 = nn.Linear(self.h2_dec_size, self.h1_dec_size, bias = True) + self.out_layer = nn.Linear(self.h1_dec_size, self.out_dim) + + def forward(self, x): + inp = x.view(-1, self.inp_dimen) + h1_out = F.relu(self.layer1(inp)) + h2_out = F.relu(self.layer2(h1_out)) + h3_out = F.relu(self.layer3(h2_out)) + + h4_out = F.relu(self.layer4(h3_out)) + h5_out = F.relu(self.layer5(h4_out)) + h6_out = F.relu(self.layer6(h5_out)) + output = F.relu(self.out_layer(h6_out)) + return output + + + + +params = startup.setup_data() +postGad_train_data = params['postGad_train_data'] +preGad_train_data = params['preGad_train_data'] +postGad_valid_data = params['postGad_test_data'] +preGad_valid_data = params['preGad_test_data'] +base_dir = params['base_dir'] +num_batches = params['num_batches'] +num_epochs = params['num_epochs'] +numVox = params['numVox'] +index_list = params['index_list'] +model_name = params['model_name'] +logfilename = params['logfilename'] +out_dir = params['out_dir'] +model_id = params['model_id'] +step_size = params['step_size'] +activation = params['activation'] +batch_size = params['batch_size'] +opt_flag = params['opt_flag'] +loss_flag = params['loss_flag'] + +num_epochs = num_epochs +batch_size = batch_size +learning_rate = step_size +momentum = params['momentum'] +data_dim = numVox + +#Define Logger and output files +loss_function_file = out_dir + 'Loss.txt' +fid_loss = open(loss_function_file, 'w') +logging.basicConfig(filename = logfilename, level = logging.INFO) + + +## Define the network +mlp_net = MLP_autoencoder(data_dim) +if loss_flag == 'SSD': + criterion = nn.MSELoss() + print(loss_flag) +elif loss_flag == 'KL': + criterion = nn.KLDivLoss() + print(loss_flag) +elif loss_flag == 'BCE': + criterion = nn.BCELoss() + print(loss_flag) +else: + criterion = nn.MSELoss() + print('Using Default Loss') + +if opt_flag == 'SGD': + optimizer = torch.optim.SGD(mlp_net.parameters(), lr = learning_rate, momentum = momentum) +elif opt_flag == 'Adam': + optimizer = torch.optim.Adam(mlp_net.parameters(), lr = learning_rate) +else: + print('Define an optimizer!! Check flags ') + +print(postGad_train_data.shape) +postGad_train_tensor = torch.from_numpy(postGad_train_data).float() +preGad_train_tensor = torch.from_numpy(preGad_train_data).float() + +postGad_valid_tensor = torch.from_numpy(postGad_valid_data).float() +preGad_valid_tensor = torch.from_numpy(preGad_valid_data).float() + +valid_data = torch.utils.data.TensorDataset(postGad_valid_tensor, preGad_valid_tensor) +validloader = torch.utils.data.DataLoader(valid_data, batch_size=batch_size, shuffle = True, drop_last = False) + +#Divide data in batches +train_data = torch.utils.data.TensorDataset(postGad_train_tensor, preGad_train_tensor) +trainloader = torch.utils.data.DataLoader(train_data, batch_size = batch_size, shuffle = True, drop_last = False) + + + +## Training the network +for epoch in range(num_epochs): + training_loss = 0.0 + starttime = time.time() + + for i, data_i in enumerate(trainloader, 0): + postGad, preGad = data_i # Comes from previous line + + features_in, features_out = Variable(postGad), Variable(preGad) + optimizer.zero_grad() + + # feed forward the batch to network and compute the loss + output = mlp_net(features_in) + loss = criterion(output, features_out) + + # Compute the gradient and update weights + loss.backward() + optimizer.step() + training_loss += loss.data[0] + + ## Validation Set + validation_loss = 0.0 + for i, valid_data_i in enumerate(validloader, 0): + postGad_v_data, preGad_v_data = valid_data_i + features_v_i, features_v_o = Variable(postGad_v_data), Variable(preGad_v_data) + output = mlp_net(features_v_i) + loss = criterion(output, features_v_o) + validation_loss += loss.data[0] + + + print ('[epoch: %d] Training loss: %.3f, Validation loss %.3f, elapsed time: %.2f' %(epoch+1, training_loss / (i+1), validation_loss/(i+1), time.time() - starttime)) + log_str = 'Epoch: ' + str(epoch + 1) + ' Training Loss: ' + str(training_loss/(i+1)) + ' Validation loss: ' + str(validation_loss/(i+1)) + ' Time Elapsed ' + str(time.time() - starttime) + disp_str = str(training_loss/(i+1)) + '\t' + str(validation_loss/(i+1)) + '\n' + fid_loss.write(disp_str) + logging.info(log_str) + +## Save Model +full_model_path = model_name + '.pkl' +torch.save(mlp_net.state_dict(), full_model_path) diff --git a/pytorch_implementation/MLP_v3.py b/pytorch_implementation/MLP_v3.py new file mode 100755 index 0000000..2ee93b1 --- /dev/null +++ b/pytorch_implementation/MLP_v3.py @@ -0,0 +1,161 @@ +import numpy as np +import sys, os, logging +import startup_header_code as startup +import torch +from torch.autograd import Variable +import torch.nn.functional as F +import torch.nn as nn +import torch.utils.data +import time +import logging + +class MLP_autoencoder(nn.Module): + + def __init__(self, input_dimension): + super(MLP_autoencoder, self).__init__() + + # Input the layer definition + self.inp_dimen = input_dimension + self.h0_enc_size = 256 + self.h1_enc_size = 128 + self.h2_enc_size = 64 + self.h3_enc_size = 32 + + self.h3_dec_size = 32 + self.h2_dec_size = 64 + self.h1_dec_size = 128 + self.h0_dec_size = 256 + self.out_dim = input_dimension + + self.layer1 = nn.Linear(self.inp_dimen, self.h0_enc_size, bias = True) + self.layer2 = nn.Linear(self.h0_enc_size, self.h1_enc_size, bias = True) + self.layer3 = nn.Linear(self.h1_enc_size, self.h2_enc_size, bias = True) + self.layer4 = nn.Linear(self.h2_enc_size, self.h3_enc_size, bias = True) + + self.layer4 = nn.Linear(self.h3_enc_size, self.h3_dec_size, bias = True) + self.layer5 = nn.Linear(self.h3_dec_size, self.h2_dec_size, bias = True) + self.layer6 = nn.Linear(self.h2_dec_size, self.h1_dec_size, bias = True) + self.layer7 = nn.Linear(self.h1_dec_size, self.h0_dec_size, bias = True) + self.out_layer = nn.Linear(self.h0_dec_size, self.out_dim) + + def forward(self, x): + inp = x.view(-1, self.inp_dimen) + h1_out = F.relu(self.layer1(inp)) + h2_out = F.relu(self.layer2(h1_out)) + h3_out = F.relu(self.layer3(h2_out)) + + h4_out = F.relu(self.layer4(h3_out)) + h5_out = F.relu(self.layer5(h4_out)) + h6_out = F.relu(self.layer6(h5_out)) + output = F.relu(self.out_layer(h6_out)) + return output + + + + +params = startup.setup_data() +postGad_train_data = params['postGad_train_data'] +preGad_train_data = params['preGad_train_data'] +postGad_valid_data = params['postGad_test_data'] +preGad_valid_data = params['preGad_test_data'] +base_dir = params['base_dir'] +num_batches = params['num_batches'] +num_epochs = params['num_epochs'] +numVox = params['numVox'] +index_list = params['index_list'] +model_name = params['model_name'] +logfilename = params['logfilename'] +out_dir = params['out_dir'] +model_id = params['model_id'] +step_size = params['step_size'] +activation = params['activation'] +batch_size = params['batch_size'] +opt_flag = params['opt_flag'] +loss_flag = params['loss_flag'] + +num_epochs = num_epochs +batch_size = batch_size +learning_rate = step_size +momentum = params['momentum'] +data_dim = numVox + +#Define Logger and output files +loss_function_file = out_dir + 'Loss.txt' +fid_loss = open(loss_function_file, 'w') +logging.basicConfig(filename = logfilename, level = logging.INFO) + + +## Define the network +mlp_net = MLP_autoencoder(data_dim) +if loss_flag == 'SSD': + criterion = nn.MSELoss() + print(loss_flag) +elif loss_flag == 'KL': + criterion = nn.KLDivLoss() + print(loss_flag) +elif loss_flag == 'BCE': + criterion = nn.BCELoss() + print(loss_flag) +else: + criterion = nn.MSELoss() + print('Using Default Loss') + + +optimizer = torch.optim.SGD(mlp_net.parameters(), lr = learning_rate, momentum = momentum) + + +print(postGad_train_data.shape) +postGad_train_tensor = torch.from_numpy(postGad_train_data).float() +preGad_train_tensor = torch.from_numpy(preGad_train_data).float() + +postGad_valid_tensor = torch.from_numpy(postGad_valid_data).float() +preGad_valid_tensor = torch.from_numpy(preGad_valid_data).float() + +valid_data = torch.utils.data.TensorDataset(postGad_valid_tensor, preGad_valid_tensor) +validloader = torch.utils.data.DataLoader(valid_data, batch_size=batch_size, shuffle = True, drop_last = False) + +#Divide data in batches +train_data = torch.utils.data.TensorDataset(postGad_train_tensor, preGad_train_tensor) +trainloader = torch.utils.data.DataLoader(train_data, batch_size = batch_size, shuffle = True, drop_last = False) + + + +## Training the network +for epoch in range(num_epochs): + training_loss = 0.0 + starttime = time.time() + + for i, data_i in enumerate(trainloader, 0): + postGad, preGad = data_i # Comes from previous line + + features_in, features_out = Variable(postGad), Variable(preGad) + optimizer.zero_grad() + + # feed forward the batch to network and compute the loss + output = mlp_net(features_in) + loss = criterion(output, features_out) + + # Compute the gradient and update weights + loss.backward() + optimizer.step() + training_loss += loss.data[0] + + ## Validation Set + validation_loss = 0.0 + for i, valid_data_i in enumerate(validloader, 0): + postGad_v_data, preGad_v_data = valid_data_i + features_v_i, features_v_o = Variable(postGad_v_data), Variable(preGad_v_data) + output = mlp_net(features_v_i) + loss = criterion(output, features_v_o) + validation_loss += loss.data[0] + + + print ('[epoch: %d] Training loss: %.3f, Validation loss %.3f, elapsed time: %.2f' %(epoch+1, training_loss / (i+1), validation_loss/(i+1), time.time() - starttime)) + log_str = 'Epoch: ' + str(epoch + 1) + ' Training Loss: ' + str(training_loss/(i+1)) + ' Validation loss: ' + str(validation_loss/(i+1)) + ' Time Elapsed ' + str(time.time() - starttime) + disp_str = str(training_loss/(i+1)) + '\t' + str(validation_loss/(i+1)) + '\n' + fid_loss.write(disp_str) + logging.info(log_str) + +## Save Model +full_model_path = model_name + '.pkl' +torch.save(mlp_net.state_dict(), full_model_path) diff --git a/pytorch_implementation/startup_header_code.py b/pytorch_implementation/startup_header_code.py new file mode 100755 index 0000000..22db45a --- /dev/null +++ b/pytorch_implementation/startup_header_code.py @@ -0,0 +1,71 @@ +import numpy as np +import tensorflow as tf +import sys +import os + + +def setup_data(): + base_dir = sys.argv[1] + out_dir = sys.argv[2] + batch_size = int(sys.argv[3]) + num_epochs = int(sys.argv[4]) + model_name = sys.argv[5] + model_id = sys.argv[6] + step = float(sys.argv[7]) + activation = sys.argv[8] + opt_flag = sys.argv[9] + momentum_val = float(sys.argv[10]) + loss_flag = sys.argv[11] + data_flag = sys.argv[12] + + if data_flag == 'Full': + postGad_train_file_name = base_dir + 'train_postGad.npy' + preGad_train_file_name = base_dir + 'train_preGad.npy' + postGad_test_file_name = base_dir + 'valid_postGad.npy' + preGad_test_file_name = base_dir + 'valid_preGad.npy' + else: + print('Running_reduced files') + postGad_train_file_name = base_dir + 'temp_train_postGad.npy' + preGad_train_file_name = base_dir + 'temp_train_preGad.npy' + postGad_test_file_name = base_dir + 'temp_valid_postGad.npy' + preGad_test_file_name = base_dir + 'temp_valid_preGad.npy' + + postGad_train_data = np.load(postGad_train_file_name) + preGad_train_data = np.load(preGad_train_file_name) + postGad_test_data = np.load(postGad_test_file_name) + preGad_test_data = np.load(preGad_test_file_name) + log_file_name = out_dir + 'log_file.txt' + + num_train = postGad_train_data.shape[0] + num_batches = int(num_train/batch_size) + + + + temp_img = postGad_train_data[0,:] + numVox = postGad_train_data.shape[1] + imageShape =np.sqrt(numVox) + full_model_name = out_dir + model_name + + # Compute index list + index_list = np.arange(0, num_train, batch_size, dtype=int) + params = {'postGad_train_data': postGad_train_data, \ + 'preGad_train_data' : preGad_train_data, \ + 'postGad_test_data' : postGad_test_data, \ + 'preGad_test_data' : preGad_test_data, \ + 'base_dir' : base_dir, \ + 'num_batches': num_batches, \ + 'numVox': numVox, \ + 'index_list': index_list, \ + 'logfilename': log_file_name, \ + 'model_name': full_model_name, \ + 'out_dir': out_dir, \ + 'num_epochs': num_epochs, \ + 'model_id' : model_id, \ + 'step_size': step, \ + 'activation': activation, \ + 'batch_size' : batch_size, \ + 'momentum' : momentum_val, \ + 'opt_flag' : opt_flag, \ + 'loss_flag' : loss_flag } + + return params diff --git a/pytorch_implementation/startup_header_code_predict.py b/pytorch_implementation/startup_header_code_predict.py new file mode 100755 index 0000000..821aa2b --- /dev/null +++ b/pytorch_implementation/startup_header_code_predict.py @@ -0,0 +1,26 @@ +import numpy as np +import tensorflow as tf +import sys +import os + + +def setup_data(): + base_dir = sys.argv[1] + out_dir = sys.argv[2] + model_name = sys.argv[3] + model_dir = sys.argv[4] + + postGad_valid_file_name = base_dir + 'temp_train_postGad.npy' + preGad_valid_file_name = base_dir + 'temp_train_preGad.npy' + postGad_valid_data = np.load(postGad_valid_file_name) + preGad_valid_data = np.load(preGad_valid_file_name) + + + # Compute index list + params = {'postGad_valid_data': postGad_valid_data[0:10,:], \ + 'preGad_valid_data' : preGad_valid_data[0:10,:], \ + 'out_dir' : out_dir, \ + 'model_name' : model_name, \ + 'model_dir': model_dir \ + } + return params diff --git a/pytorch_implementation/submit_jobs.sh b/pytorch_implementation/submit_jobs.sh new file mode 100755 index 0000000..76e74e1 --- /dev/null +++ b/pytorch_implementation/submit_jobs.sh @@ -0,0 +1,29 @@ +#$ -S /bin/bash +#$ -N output +#$ -o /ifs/loni/faculty/thompson/four_d/vgupta/Tools/Remove_GadContrast/pytorch_implementation/logs + + +py_dir=/ifs/loni/faculty/thompson/four_d/vgupta/Tools/Softwares/miniconda3/bin +apps_dir=/ifs/loni/faculty/thompson/four_d/vgupta/Tools/Remove_GadContrast/pytorch_implementation + +base_dir=/ifs/loni/faculty/thompson/four_d/vgupta/Data/Gad_data/rawdicoms/numpy_data/ +num_epochs=3 +model_name=MLP +model_id=3 +activation=relu +opt_flag=SGD +momentum=0.9 +data_flag=temp +<