def init_cnn(): net = NeuralNet( layers=[ # input layer (layers.InputLayer, { 'shape': (None, bastdm5.classification.settings.CHANNELS, bastdm5.classification.settings.MINI_SEGMENT_LENGTH, bastdm5.classification.settings.MEL_DATA_POINTS) }), # convolution layers 1 (layers.Conv2DLayer, { 'num_filters': 32, 'filter_size': (8, 1) }), (layers.MaxPool2DLayer, { 'pool_size': (4, 1), 'stride': (2, 1) }), # convolution layers 2 (layers.Conv2DLayer, { 'num_filters': 32, 'filter_size': (8, 1) }), (layers.MaxPool2DLayer, { 'pool_size': (4, 1), 'stride': (2, 1) }), # dense layer (layers.DenseLayer, { 'num_units': 100 }), (layers.DropoutLayer, {}), (layers.DenseLayer, { 'num_units': 50 }), # output layer (layers.DenseLayer, { 'num_units': 6, 'nonlinearity': nonlinearities.softmax }) ], # learning rate parameters update_learning_rate=0.001, update_momentum=0.9, regression=False, max_epochs=999, verbose=1, ) net.batch_iterator_test = TestSegmentBatchIterator( batch_size=bastdm5.classification.settings.MINI_BATCH_SIZE) y_mapping = utils.load_from_pickle(CNN_Y_MAPPING_PATH) net.load_params_from(CNN_WEIGHTS_PATH) return net, y_mapping
def __call__(self, nn, train_history): current_valid = train_history[-1]['valid_loss'] current_epoch = train_history[-1]['epoch'] if current_valid < self.best_valid: self.best_valid = current_valid self.best_valid_epoch = current_epoch self.best_weights = nn.get_all_params_values() elif self.best_valid_epoch + self.patience < current_epoch: print("Early stopping.") print("Best valid loss was {:.6f} at epoch {}.".format( self.best_valid, self.best_valid_epoch)) nn.load_params_from(self.best_weights) raise StopIteration()
class network(object): def __init__(self,X_train, Y_train): #self.__hidden=0 self.__hidden=int(math.ceil((2*(X_train.shape[1]+ 1))/3)) self.net= NeuralNet( layers=[ ('input', layers.InputLayer), ('hidden', layers.DenseLayer), ('output', layers.DenseLayer) ], input_shape=( None, X_train.shape[1] ), hidden_num_units=self.__hidden, #hidden_nonlinearity=nonlinearities.tanh, output_nonlinearity=None, batch_iterator_train=BatchIterator(batch_size=256), output_num_units=1, on_epoch_finished=[EarlyStopping(patience=50)], update=momentum, update_learning_rate=theano.shared(np.float32(0.03)), update_momentum=theano.shared(np.float32(0.8)), regression=True, max_epochs=1000, verbose=1, ) self.net.fit(X_train,Y_train) def predict(self,X): return self.net.predict(X) def showMetrics(self): train_loss = np.array([i["train_loss"] for i in self.net.train_history_]) valid_loss = np.array([i["valid_loss"] for i in self.net.train_history_]) pyplot.plot(train_loss, linewidth=3, label="training") pyplot.plot(valid_loss, linewidth=3, label="validation") pyplot.grid() pyplot.legend() pyplot.xlabel("epoch") pyplot.ylabel("loss") # pyplot.ylim(1e-3, 1e-2) pyplot.yscale("log") pyplot.show() def saveNet(self,fname): self.net.save_params_to(fname) def loadNet(self,fname): self.net.load_params_from(fname)
class network(object): def __init__(self, X_train, Y_train): #self.__hidden=0 self.__hidden = int(math.ceil((2 * (X_train.shape[1] + 1)) / 3)) self.net = NeuralNet( layers=[('input', layers.InputLayer), ('hidden', layers.DenseLayer), ('output', layers.DenseLayer)], input_shape=(None, X_train.shape[1]), hidden_num_units=self.__hidden, #hidden_nonlinearity=nonlinearities.tanh, output_nonlinearity=None, batch_iterator_train=BatchIterator(batch_size=256), output_num_units=1, on_epoch_finished=[EarlyStopping(patience=50)], update=momentum, update_learning_rate=theano.shared(np.float32(0.03)), update_momentum=theano.shared(np.float32(0.8)), regression=True, max_epochs=1000, verbose=1, ) self.net.fit(X_train, Y_train) def predict(self, X): return self.net.predict(X) def showMetrics(self): train_loss = np.array( [i["train_loss"] for i in self.net.train_history_]) valid_loss = np.array( [i["valid_loss"] for i in self.net.train_history_]) pyplot.plot(train_loss, linewidth=3, label="training") pyplot.plot(valid_loss, linewidth=3, label="validation") pyplot.grid() pyplot.legend() pyplot.xlabel("epoch") pyplot.ylabel("loss") # pyplot.ylim(1e-3, 1e-2) pyplot.yscale("log") pyplot.show() def saveNet(self, fname): self.net.save_params_to(fname) def loadNet(self, fname): self.net.load_params_from(fname)
def loadNet2(netName): net = NeuralNet( layers=[ ('input', layers.InputLayer), ('conv1', layers.Conv2DLayer), ('pool1', layers.MaxPool2DLayer), ('dropout1', layers.DropoutLayer), # ! ('conv2', layers.Conv2DLayer), ('pool2', layers.MaxPool2DLayer), ('dropout2', layers.DropoutLayer), # ! ('conv3', layers.Conv2DLayer), ('pool3', layers.MaxPool2DLayer), ('dropout3', layers.DropoutLayer), # ! ('hidden4', layers.DenseLayer), ('dropout4', layers.DropoutLayer), # ! ('hidden5', layers.DenseLayer), ('output', layers.DenseLayer), ], input_shape=(None, 1, 96, 96), conv1_num_filters=32, conv1_filter_size=(3, 3), pool1_pool_size=(2, 2), dropout1_p=0.1, # ! conv2_num_filters=64, conv2_filter_size=(2, 2), pool2_pool_size=(2, 2), dropout2_p=0.2, # ! conv3_num_filters=128, conv3_filter_size=(2, 2), pool3_pool_size=(2, 2), dropout3_p=0.3, # ! hidden4_num_units=1000, # ! dropout4_p=0.5, hidden5_num_units=1000, # ! output_num_units=30, output_nonlinearity=None, update_learning_rate=theano.shared(float32(0.03)), update_momentum=theano.shared(float32(0.9)), regression=True, batch_iterator_train=FlipBatchIterator(batch_size=128), on_epoch_finished=[ AdjustVariable('update_learning_rate', start=0.03, stop=0.0001), AdjustVariable('update_momentum', start=0.9, stop=0.999), EarlyStopping(patience=200), backupCNN, ], max_epochs=10000, verbose=1, ) net.load_params_from(netName) return net
def main(resume=None): l = 300 dataset = './data/ubiquitous_train.hkl' print('Loading dataset {}...'.format(dataset)) X_train, y_train = hkl.load(dataset) X_train = X_train.reshape(-1, 4, 1, l).astype(floatX) y_train = np.array(y_train, dtype='int32') indice = np.arange(X_train.shape[0]) np.random.shuffle(indice) X_train = X_train[indice] y_train = y_train[indice] print('X_train shape: {}, y_train shape: {}'.format(X_train.shape, y_train.shape)) layers = [ (InputLayer, {'shape': (None, 4, 1, l)}), (Conv2DLayer, {'num_filters': 64, 'filter_size': (1, 4)}), (Conv2DLayer, {'num_filters': 64, 'filter_size': (1, 3)}), (Conv2DLayer, {'num_filters': 64, 'filter_size': (1, 3)}), (MaxPool2DLayer, {'pool_size': (1, 2)}), (Conv2DLayer, {'num_filters': 64, 'filter_size': (1, 2)}), (Conv2DLayer, {'num_filters': 64, 'filter_size': (1, 2)}), (Conv2DLayer, {'num_filters': 64, 'filter_size': (1, 2)}), (MaxPool2DLayer, {'pool_size': (1, 2)}), (DenseLayer, {'num_units': 64}), (DropoutLayer, {}), (DenseLayer, {'num_units': 64}), (DenseLayer, {'num_units': 2, 'nonlinearity': softmax})] lr = theano.shared(np.float32(1e-4)) net = NeuralNet( layers=layers, max_epochs=100, update=adam, update_learning_rate=lr, train_split=TrainSplit(eval_size=0.1), on_epoch_finished=[ AdjustVariable(lr, target=1e-8, half_life=20)], verbose=4) if resume != None: net.load_params_from(resume) net.fit(X_train, y_train) net.save_params_to('./models/net_params.pkl')
def load_finetuned_dbn(path): """ Load a fine tuned Deep Belief Net from file :param path: path to deep belief net parameters :return: deep belief net """ dbn = NeuralNet(layers=[('input', las.layers.InputLayer), ('l1', las.layers.DenseLayer), ('l2', las.layers.DenseLayer), ('l3', las.layers.DenseLayer), ('l4', las.layers.DenseLayer), ('l5', las.layers.DenseLayer), ('l6', las.layers.DenseLayer), ('l7', las.layers.DenseLayer), ('output', las.layers.DenseLayer)], input_shape=(None, 1200), l1_num_units=2000, l1_nonlinearity=sigmoid, l2_num_units=1000, l2_nonlinearity=sigmoid, l3_num_units=500, l3_nonlinearity=sigmoid, l4_num_units=50, l4_nonlinearity=linear, l5_num_units=500, l5_nonlinearity=sigmoid, l6_num_units=1000, l6_nonlinearity=sigmoid, l7_num_units=2000, l7_nonlinearity=sigmoid, output_num_units=1200, output_nonlinearity=linear, update=nesterov_momentum, update_learning_rate=0.001, update_momentum=0.5, objective_l2=0.005, verbose=1, regression=True) with open(path, 'rb') as f: pretrained_nn = pickle.load(f) if pretrained_nn is not None: dbn.load_params_from(path) return dbn
class CNN(object): __metaclass__ = Singleton channels = 3 image_size = [64,64] layers = [ # layer dealing with the input data (InputLayer, {'shape': (None, channels, image_size[0], image_size[1])}), # first stage of our convolutional layers (Conv2DLayer, {'num_filters': 32, 'filter_size': 9}), (Conv2DLayer, {'num_filters': 32, 'filter_size': 5}), (MaxPool2DLayer, {'pool_size': 2}), # second stage of our convolutional layers (Conv2DLayer, {'num_filters': 32, 'filter_size': 5}), (Conv2DLayer, {'num_filters': 32, 'filter_size': 3}), (MaxPool2DLayer, {'pool_size': 2}), # two dense layers with dropout (DenseLayer, {'num_units': 256}), (DropoutLayer, {}), (DenseLayer, {'num_units': 256}), # the output layer (DenseLayer, {'num_units': 2, 'nonlinearity': softmax}), ] def __init__(self): logger = logging.getLogger(__name__) logger.info("Initializing neural net...") self.net = NeuralNet(layers=self.layers, update_learning_rate=0.0002 ) self.net.load_params_from("conv_params") logger.info("Finished loading parameters") def resize(self, infile): try: im = Image.open(infile) resized_im = np.array(ImageOps.fit(im, (self.image_size[0], self.image_size[1]), Image.ANTIALIAS), dtype=np.uint8) rgb = np.array([resized_im[:,:,0], resized_im[:,:,1], resized_im[:,:,2]]) return rgb.reshape(1,self.channels,self.image_size[0],self.image_size[1]) except IOError: return "cannot create thumbnail for '%s'" % infile def predict(self, X): p**n = self.net.predict(X)[0] == 1 return "true" if p**n else "false"
def model_train(X_train, y_train, learning_rate=1e-4, epochs=50): network = create_network() lr = theano.shared(np.float32(learning_rate)) net = NeuralNet( network, max_epochs=epochs, update=adam, update_learning_rate=lr, train_split=TrainSplit(eval_size=0.1), batch_iterator_train=BatchIterator(batch_size=32), batch_iterator_test=BatchIterator(batch_size=64), #on_training_started=[LoadBestParam(iteration=val_acc.argmax())], on_epoch_finished=[EarlyStopping(patience=5)], verbose=1) print 'Loading pre-training weights...' net.load_params_from(params[val_acc.argmax()]) print 'Continue to train...' net.fit(X_train, y_train) print 'Model training finished.' return net
def operate(data): # data = [0.0592330098, 0.140761971, 0.0757750273, 0.119381011, 0.0651519895, 0.120247006, 0.0454769731] batch_size = len(data) thres = 0.4 net = NeuralNet( layers=[('input', layers.InputLayer), ('hidden', layers.DenseLayer), ('output', layers.DenseLayer), ], # layer parameters: input_shape=(None, batch_size), hidden_num_units=batch_size, # number of units in 'hidden' layer hidden_nonlinearity=lasagne.nonlinearities.sigmoid, output_nonlinearity=lasagne.nonlinearities.elu, output_num_units=batch_size, # 10 target values for the digits 0, 1, 2, ..., 9 # optimization method: update=nesterov_momentum, update_learning_rate=0.1, update_momentum=0.9, max_epochs=2000, verbose=1, regression=True, objective_loss_function=lasagne.objectives.squared_error # custom_score=("validation score", lambda x, y: np.mean(np.abs(x - y))) ) net.load_params_from("/home/loringit/Bulat/neuron/bulik_nn") net_answer = net.predict([data]) result = np.linalg.norm(data - net_answer) # return result < thres if result < thres: return "true" else: return "false"
def main(deepL, alignments): S, X = make_xy(alignments, deepL['features']) h = DictVectorizer(sparse=False) X = h.fit_transform(X) X = X.astype(floatX) # normalize feature matrix min_max_scaler = preprocessing.MinMaxScaler() X = min_max_scaler.fit_transform(X) clf = NeuralNet( layers=model(deepL['input_nodes'], deepL['output_nodes']), update=nesterov_momentum, update_learning_rate=0.01, update_momentum=0.9, regression=False, max_epochs=100, verbose=2, ) clf.load_params_from(opt.path + "/model/model.pkl") proba = clf.predict_proba(X) preds = [] probs = [] deepL['Y_rev'].update({10000: "unclassified"}) for ipx, p in enumerate(proba): px = np.argmax(p) if p[px] > min_prob[deepL['Y_rev'][px]]: preds.append(px) probs.append(p[px]) else: preds.append(10000) probs.append(0) return [[S[ix], deepL['Y_rev'][i], probs[ix]] for ix, i in enumerate(preds)]
def load_finetuned_dbn(path): """ Load a fine tuned Deep Belief Net from file :param path: path to deep belief net parameters :return: deep belief net """ dbn = NeuralNet( layers=[ ('input', las.layers.InputLayer), ('l1', las.layers.DenseLayer), ('l2', las.layers.DenseLayer), ('l3', las.layers.DenseLayer), ('l4', las.layers.DenseLayer), ('l5', las.layers.DenseLayer), ('l6', las.layers.DenseLayer), ('l7', las.layers.DenseLayer), ('output', las.layers.DenseLayer) ], input_shape=(None, 1200), l1_num_units=2000, l1_nonlinearity=sigmoid, l2_num_units=1000, l2_nonlinearity=sigmoid, l3_num_units=500, l3_nonlinearity=sigmoid, l4_num_units=50, l4_nonlinearity=linear, l5_num_units=500, l5_nonlinearity=sigmoid, l6_num_units=1000, l6_nonlinearity=sigmoid, l7_num_units=2000, l7_nonlinearity=sigmoid, output_num_units=1200, output_nonlinearity=linear, update=nesterov_momentum, update_learning_rate=0.001, update_momentum=0.5, objective_l2=0.005, verbose=1, regression=True ) with open(path, 'rb') as f: pretrained_nn = pickle.load(f) if pretrained_nn is not None: dbn.load_params_from(path) return dbn
def recunstruct_cae(folder_path): cnn = NeuralNet() cnn.load_params_from(folder_path + CONV_AE_PARAMS_PKL) cnn.load_weights_from(folder_path + CONV_AE_NP) return cnn
total_test_time_points = len(X_test) // NO_TIME_POINTS remainder_test_points = len(X_test) % NO_TIME_POINTS no_rows = total_test_time_points * NO_TIME_POINTS X_test = X_test[0:no_rows, :] X_test = X_test.transpose() X_test_Samples = np.split(X_test, total_test_time_points, axis=1) X_test = np.asarray(X_test_Samples) ########################################################################### #######get predictions and write to files for series 9 and series 10####### print("Testing subject%d...." %(subject)) params = net.get_all_params_values() learned_weights = net.load_params_from(params) probabilities = net.predict_proba(X_test) sub9 = 'subj{0}_series{1}'.format(subject, 9) data_len9 = test_dict[sub9] total_time_points9 = data_len9 // NO_TIME_POINTS remainder_data9 = data_len9 % NO_TIME_POINTS sub10 = 'subj{0}_series{1}'.format(subject, 10) data_len10 = test_dict[sub10] total_time_points10 = data_len10 // NO_TIME_POINTS remainder_data10 = data_len10 % NO_TIME_POINTS total_test_points = total_time_points9+total_time_points10 for i, p in enumerate(probabilities):
def main(): data = load_av_letters('data/allData_mouthROIs.mat') # create the necessary variable mappings data_matrix = data['dataMatrix'] data_matrix_len = data_matrix.shape[0] targets_vec = data['targetsVec'] vid_len_vec = data['videoLengthVec'] iter_vec = data['iterVec'] indexes = create_split_index(data_matrix_len, vid_len_vec, iter_vec) # split the data train_data = data_matrix[indexes == True] train_targets = targets_vec[indexes == True] test_data = data_matrix[indexes == False] test_targets = targets_vec[indexes == False] idx = [i for i, elem in enumerate(test_targets) if elem == 20] print(train_data.shape) print(test_data.shape) print(sum([train_data.shape[0], test_data.shape[0]])) # resize the input data to 40 x 30 train_data_resized = resize_images(train_data).astype(np.float32) # normalize the inputs [0 - 1] train_data_resized = normalize_input(train_data_resized, centralize=True) test_data_resized = resize_images(test_data).astype(np.float32) test_data_resized = normalize_input(test_data_resized, centralize=True) dic = {} dic['trainDataResized'] = train_data_resized dic['testDataResized'] = test_data_resized """second experiment: overcomplete sigmoid encoder/decoder, squared loss""" encode_size = 2500 sigma = 0.5 # to get tied weights in the encoder/decoder, create this shared weightMatrix # 1200 x 2000 w1, layer1 = build_encoder_layers(1200, 2500, sigma) ae1 = NeuralNet( layers=layer1, max_epochs=50, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1 ) load = True save = False if load: print('[LOAD] layer 1...') ae1.load_params_from('layer1.dat') else: print('[TRAIN] layer 1...') ae1.fit(train_data_resized, train_data_resized) # save params if save: print('[SAVE] layer 1...') ae1.save_params_to('layer1.dat') train_encoded1 = ae1.get_output('encoder', train_data_resized) # 12293 x 2000 w2, layer2 = build_encoder_layers(2500, 1250) ae2 = NeuralNet( layers=layer2, max_epochs=50, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1 ) load2 = True if load2: print('[LOAD] layer 2...') ae2.load_params_from('layer2.dat') else: print('[TRAIN] layer 2...') ae2.fit(train_encoded1, train_encoded1) save2 = False if save2: print('[SAVE] layer 2...') ae2.save_params_to('layer2.dat') train_encoded2 = ae2.get_output('encoder', train_encoded1) # 12293 x 1250 w3, layer3 = build_encoder_layers(1250, 600) ae3 = NeuralNet( layers=layer3, max_epochs=100, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1 ) load3 = True if load3: print('[LOAD] layer 3...') ae3.load_params_from('layer3.dat') else: ae3.fit(train_encoded2, train_encoded2) save3 = False if save3: print('[SAVE] layer 3...') ae3.save_params_to('layer3.dat') train_encoded3 = ae3.get_output('encoder', train_encoded2) # 12293 x 1250 w4, layer4 = build_bottleneck_layer(600, 100) ae4 = NeuralNet( layers=layer4, max_epochs=100, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1 ) load4 = False if load4: print('[LOAD] layer 4...') ae4.load_params_from('layer4.dat') else: print('[TRAIN] layer 4...') ae4.fit(train_encoded3, train_encoded3) save4 = True if save4: print('[SAVE] layer 4...') ae4.save_params_to('layer4.dat') test_enc1 = ae1.get_output('encoder', test_data_resized) test_enc2 = ae2.get_output('encoder', test_enc1) test_enc3 = ae3.get_output('encoder', test_enc2) test_enc4 = ae4.get_output('encoder', test_enc3) decoder4 = create_decoder(100, 600, w4.T) decoder4.initialize() decoder3 = create_decoder(600, 1250, w3.T) decoder3.initialize() decoder2 = create_decoder(1250, 2500, w2.T) decoder2.initialize() # initialize the net decoder1 = create_decoder(2500, 1200, w1.T) decoder1.initialize() test_dec3 = decoder4.predict(test_enc4) test_dec2 = decoder3.predict(test_dec3) test_dec1 = decoder2.predict(test_dec2) X_pred = decoder1.predict(test_dec1) # plot_loss(ae3) # plot_loss(ae2) # plot_loss(ae1) tile_raster_images(X_pred[4625:4650, :], (30, 40), (5, 5), tile_spacing=(1, 1)) plt.title('reconstructed') tile_raster_images(test_data_resized[4625:4650, :], (30, 40), (5, 5), tile_spacing=(1, 1)) plt.title('original') plt.show() """
def rodar(self, numerodeimagens): np.set_printoptions(threshold=np.nan) sourcepath = str(os.getcwd()) # Allocates space for each new image you want to classify, each line is an image X_test = np.zeros((numerodeimagens, 19200), dtype=np.int) strfiles ='' i = 0 # read the images for files in glob.glob(os.path.join(sourcepath, '*.jpeg')): X_test[i] = np.asarray(Image.open(files)).reshape(-1)[0:19200] strfiles += files + '<br>' i += 1 # Reshape the images to help the CNN execution X_test = X_test.reshape((-1, 3, 80, 80)) # Define the CNN, must be the same CNN saved into your model generated running CNN.py net1 = NeuralNet( layers=[('input', layers.InputLayer), ('conv2d1', layers.Conv2DLayer), ('maxpool1', layers.MaxPool2DLayer), ('conv2d2', layers.Conv2DLayer), ('maxpool2', layers.MaxPool2DLayer), ('conv2d3', layers.Conv2DLayer), ('maxpool3', layers.MaxPool2DLayer), # ('conv2d4', layers.Conv2DLayer), # ('maxpool4', layers.MaxPool2DLayer), ('dropout1', layers.DropoutLayer), # s('dropout2', layers.DropoutLayer), ('dense', layers.DenseLayer), # ('dense2', layers.DenseLayer), ('output', layers.DenseLayer), ], input_shape=(None, 3, 80, 80), conv2d1_num_filters=16, conv2d1_filter_size=(3, 3), conv2d1_nonlinearity=lasagne.nonlinearities.rectify, conv2d1_W=lasagne.init.GlorotUniform(), maxpool1_pool_size=(2, 2), conv2d2_num_filters=16, conv2d2_filter_size=(3, 3), conv2d2_nonlinearity=lasagne.nonlinearities.rectify, maxpool2_pool_size=(2, 2), conv2d3_num_filters=16, conv2d3_filter_size=(3, 3), conv2d3_nonlinearity=lasagne.nonlinearities.rectify, maxpool3_pool_size=(2, 2), # conv2d4_num_filters = 16, # conv2d4_filter_size = (2,2), # conv2d4_nonlinearity = lasagne.nonlinearities.rectify, # maxpool4_pool_size = (2,2), dropout1_p=0.5, # dropout2_p = 0.5, dense_num_units=16, dense_nonlinearity=lasagne.nonlinearities.rectify, # dense2_num_units = 16, # dense2_nonlinearity = lasagne.nonlinearities.rectify, output_nonlinearity=lasagne.nonlinearities.softmax, output_num_units=2, update=nesterov_momentum, update_learning_rate=0.001, update_momentum=0.9, max_epochs=1000, verbose=1, ) net1.load_params_from(os.path.join(sourcepath, "#0#0#0#.txt")) # Read model preds = net1.predict(X_test) # make predictions strfiles = strfiles.replace(str(os.getcwd()), "").replace(".jpeg", '').replace("/", '') strfiles = strfiles.split("<br>") strpreds = str(preds) strpreds = strpreds.replace("1", "yes") strpreds = strpreds.replace("0", "no") strpreds = strpreds.split(" ") for i in range(0, numerodeimagens): strpreds[i] += " >> " + strfiles[i] strpreds = str(strpreds) strpreds = strpreds.replace(",", "<br>") strpreds = strpreds.replace("[", "") strpreds = strpreds.replace("]", "") strpreds = strpreds.replace("'", "") return strpreds
def flush(self): # this flush method is needed for python 3 compatibility. # this handles the flush command by doing nothing. # you might want to specify some extra behavior here. pass sys.stdout = Logger() # cnn init # cnn.load_params_from('./model_trained_on_UCF.pkl'); if os.path.exists('./data_cache/cnn_' + CNNCode + '-' + TrainCode + '.pkl'): # check if a trained model already exists cnn.load_params_from('./data_cache/cnn_' + CNNCode + '-' + TrainCode + '.pkl'); else: cnn_train = time.time(); # training a new model for epoch in range(Epochs): # for every epoch for batch in patches_extract_all(Train): # for every batch inputs, targets = batch; # data augmentation inputs, targets = data_aug(inputs, targets); # run cnn.fit for 1 iteration cnn_fit = time.time(); cnn.fit(inputs, targets.reshape((-1, 1 * 32 * 32))); # print 'fitting cnn took: ', time.time()-cnn_fit, 'sec.'; # for every 10 epoch, print testing accuracy
def create_pretrained_vgg_nn_nolearn(): ''' *** This function need only be run once to create and save a nolearn NeuralNet *** *** instance from the origninal lasagne layer weights for the vgg net. *** Create a vgg neural net. Load pretrained weights. Pickle the entire net. Pickle the mean image. Return a nolearn.NeuralNet instance, mean_image numpy array ''' # define the vgg_s network vgg_nn = NeuralNet( layers=[ (InputLayer, { 'name': 'input', 'shape': (None, 3, 224, 224) }), (ConvLayer, { 'name': 'conv1', 'num_filters': 96, 'filter_size': (7, 7), 'stride': 2, 'flip_filters': False }), (NormLayer, { 'name': 'norm1', 'alpha': .0001 }), (PoolLayer, { 'name': 'pool1', 'pool_size': (3, 3), 'stride': 3, 'ignore_border': False }), ( ConvLayer, { 'name': 'conv2', 'num_filters': 256, 'filter_size': (5, 5), 'flip_filters': False # 'pad':2, # 'stride':1 }), (PoolLayer, { 'name': 'pool2', 'pool_size': (2, 2), 'stride': 2, 'ignore_border': False }), ( ConvLayer, { 'name': 'conv3', 'num_filters': 512, 'filter_size': (3, 3), 'pad': 1, # 'stride':1 'flip_filters': False }), ( ConvLayer, { 'name': 'conv4', 'num_filters': 512, 'filter_size': (3, 3), 'pad': 1, # 'stride':1 'flip_filters': False }), ( ConvLayer, { 'name': 'conv5', 'num_filters': 512, 'filter_size': (3, 3), 'pad': 1, # 'stride':1 'flip_filters': False }), (PoolLayer, { 'name': 'pool5', 'pool_size': (3, 3), 'stride': 3, 'ignore_border': False }), (DenseLayer, { 'name': 'fc6', 'num_units': 4096 }), (DropoutLayer, { 'name': 'drop6', 'p': .5 }), (DenseLayer, { 'name': 'fc7', 'num_units': 4096 }), ], # # optimization method: update=nesterov_momentum, update_learning_rate=0.01, update_momentum=0.9, # Do not need these unless trainng the net. # regression=True, # flag to indicate we're dealing with regression problem # max_epochs=400, # we want to train this many epochs # verbose=1, ) # upload pretrained weights vgg_nn.initialize() vgg_nn.load_params_from('./vgg_nolearn_saved_wts_biases.pkl') # upload mean image model = pickle.load(open('./vgg_cnn_s.pkl')) mean_image = model['mean image'] # pickel the model and the mean image with open("/data/mean_image.pkl", 'w') as f: pickle.dump(mean_image, f) with open("/data/full_vgg.pkl", 'w') as f: pickle.dump(vgg_nn, f) return vgg_net, mean_image
def main(): # Parse command line options parser = argparse.ArgumentParser( description='Test different nets with 3D data.') parser.add_argument('--flair', action='store', dest='flair', default='FLAIR_preprocessed.nii.gz') parser.add_argument('--pd', action='store', dest='pd', default='DP_preprocessed.nii.gz') parser.add_argument('--t2', action='store', dest='t2', default='T2_preprocessed.nii.gz') parser.add_argument('--t1', action='store', dest='t1', default='T1_preprocessed.nii.gz') parser.add_argument('--output', action='store', dest='output', default='output.nii.gz') parser.add_argument('--no-docker', action='store_false', dest='docker', default=True) c = color_codes() patch_size = (15, 15, 15) options = vars(parser.parse_args()) batch_size = 10000 min_size = 30 print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Loading the net ' + c['b'] + '1' + c['nc'] + c['g'] + '>' + c['nc']) net_name = '/usr/local/nets/deep-challenge2016.init.model_weights.pkl' if options['docker'] \ else './deep-challenge2016.init.model_weights.pkl' net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, verbose=10, max_epochs=50, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum( (p + t[:, 1])))], ) net.load_params_from(net_name) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Creating the probability map ' + c['b'] + '1' + c['nc'] + c['g'] + '>' + c['nc']) names = np.array( [options['flair'], options['pd'], options['t2'], options['t1']]) image_nii = load_nii(options['flair']) image1 = np.zeros_like(image_nii.get_data()) print('0% of data tested', end='\r') sys.stdout.flush() for batch, centers, percent in load_patch_batch_percent( names, batch_size, patch_size): y_pred = net.predict_proba(batch) print('%f%% of data tested' % percent, end='\r') sys.stdout.flush() [x, y, z] = np.stack(centers, axis=1) image1[x, y, z] = y_pred[:, 1] print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Loading the net ' + c['b'] + '2' + c['nc'] + c['g'] + '>' + c['nc']) net_name = '/usr/local/nets/deep-challenge2016.final.model_weights.pkl' if options['docker'] \ else './deep-challenge2016.final.model_weights.pkl' net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, batch_iterator_train=BatchIterator(batch_size=4096), verbose=10, max_epochs=2000, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda t, p: 2 * np.sum(t * p[:, 1]) / np.sum( (t + p[:, 1])))], ) net.load_params_from(net_name) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Creating the probability map ' + c['b'] + '2' + c['nc'] + c['g'] + '>' + c['nc']) image2 = np.zeros_like(image_nii.get_data()) print('0% of data tested', end='\r') sys.stdout.flush() for batch, centers, percent in load_patch_batch_percent( names, batch_size, patch_size): y_pred = net.predict_proba(batch) print('%f%% of data tested' % percent, end='\r') sys.stdout.flush() [x, y, z] = np.stack(centers, axis=1) image2[x, y, z] = y_pred[:, 1] print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Saving to file ' + c['b'] + options['output'] + c['nc'] + c['g'] + '>' + c['nc']) image = (image1 * image2) > 0.5 # filter candidates < min_size labels, num_labels = ndimage.label(image) lesion_list = np.unique(labels) num_elements_by_lesion = ndimage.labeled_comprehension( image, labels, lesion_list, np.sum, float, 0) filt_min_size = num_elements_by_lesion >= min_size lesion_list = lesion_list[filt_min_size] image = reduce(np.logical_or, map(lambda lab: lab == labels, lesion_list)) image_nii.get_data()[:] = np.roll(np.roll(image, 1, axis=0), 1, axis=1) path = '/'.join(options['t1'].rsplit('/')[:-1]) outputname = options['output'].rsplit('/')[-1] image_nii.to_filename(os.path.join(path, outputname)) if not options['docker']: path = '/'.join(options['output'].rsplit('/')[:-1]) case = options['output'].rsplit('/')[-1] gt = load_nii(os.path.join( path, 'Consensus.nii.gz')).get_data().astype(dtype=np.bool) dsc = np.sum( 2.0 * np.logical_and(gt, image)) / (np.sum(gt) + np.sum(image)) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<DSC value for ' + c['c'] + case + c['g'] + ' = ' + c['b'] + str(dsc) + c['nc'] + c['g'] + '>' + c['nc'])
def main(): parser = argparse.ArgumentParser(description='Test different nets with 3D data.') parser.add_argument('-f', '--folder', dest='dir_name', default='/home/sergivalverde/w/CNN/images/CH16') parser.add_argument('--flair', action='store', dest='flair', default='FLAIR_preprocessed.nii.gz') parser.add_argument('--pd', action='store', dest='pd', default='DP_preprocessed.nii.gz') parser.add_argument('--t2', action='store', dest='t2', default='T2_preprocessed.nii.gz') parser.add_argument('--t1', action='store', dest='t1', default='T1_preprocessed.nii.gz') parser.add_argument('--mask', action='store', dest='mask', default='Consensus.nii.gz') parser.add_argument('--old', action='store_true', dest='old', default=False) options = vars(parser.parse_args()) c = color_codes() patch_size = (15, 15, 15) batch_size = 100000 # Create the data patients = [f for f in sorted(os.listdir(options['dir_name'])) if os.path.isdir(os.path.join(options['dir_name'], f))] flair_names = [os.path.join(options['dir_name'], patient, options['flair']) for patient in patients] pd_names = [os.path.join(options['dir_name'], patient, options['pd']) for patient in patients] t2_names = [os.path.join(options['dir_name'], patient, options['t2']) for patient in patients] t1_names = [os.path.join(options['dir_name'], patient, options['t1']) for patient in patients] names = np.stack([name for name in [flair_names, pd_names, t2_names, t1_names]]) seed = np.random.randint(np.iinfo(np.int32).max) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + 'Starting leave-one-out' + c['nc']) for i in range(0, 15): case = names[0, i].rsplit('/')[-2] path = '/'.join(names[0, i].rsplit('/')[:-1]) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['nc'] + 'Patient ' + c['b'] + case + c['nc']) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Running iteration ' + c['b'] + '1' + c['nc'] + c['g'] + '>' + c['nc']) net_name = os.path.join(path, 'deep-challenge2016.init.') net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, on_epoch_finished=[ SaveWeights(net_name + 'model_weights.pkl', only_best=True, pickle=False), EarlyStopping(patience=10) ], verbose=10, max_epochs=50, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum((p + t[:, 1])))], ) flair_name = os.path.join(path, options['flair']) pd_name = os.path.join(path, options['pd']) t2_name = os.path.join(path, options['t2']) t1_name = os.path.join(path, options['t1']) names_test = np.array([flair_name, pd_name, t2_name, t1_name]) outputname1 = os.path.join(path, 'test' + str(i) + '.iter1.nii.gz') try: net.load_params_from(net_name + 'model_weights.pkl') except IOError: print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + 'Loading the data for ' + c['b'] + 'iteration 1' + c['nc']) names_lou = np.concatenate([names[:, :i], names[:, i + 1:]], axis=1) paths = ['/'.join(name.rsplit('/')[:-1]) for name in names_lou[0, :]] mask_names = [os.path.join(p_path, 'Consensus.nii.gz') for p_path in paths] x_train, y_train = load_iter1_data( names_lou=names_lou, mask_names=mask_names, patch_size=patch_size, seed=seed ) print(' Training vector shape =' ' (' + ','.join([str(length) for length in x_train.shape]) + ')') print(' Training labels shape =' ' (' + ','.join([str(length) for length in y_train.shape]) + ')') print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + 'Training (' + c['b'] + 'initial' + c['nc'] + c['g'] + ')' + c['nc']) # We try to get the last weights to keep improving the net over and over net.fit(x_train, y_train) try: image_nii = load_nii(outputname1) image1 = image_nii.get_data() except IOError: print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Creating the probability map ' + c['b'] + '1' + c['nc'] + c['g'] + '>' + c['nc']) flair_name = os.path.join(path, options['flair']) image_nii = load_nii(flair_name) image1 = np.zeros_like(image_nii.get_data()) print(' 0% of data tested', end='\r') sys.stdout.flush() for batch, centers, percent in load_patch_batch_percent(names_test, batch_size, patch_size): y_pred = net.predict_proba(batch) print(' %f%% of data tested' % percent, end='\r') sys.stdout.flush() [x, y, z] = np.stack(centers, axis=1) image1[x, y, z] = y_pred[:, 1] image_nii.get_data()[:] = image1 image_nii.to_filename(outputname1) ''' Here we get the seeds ''' print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Looking for seeds for the final iteration>' + c['nc']) for patient in np.rollaxis(np.concatenate([names[:, :i], names[:, i+1:]], axis=1), 1): outputname = os.path.join('/'.join(patient[0].rsplit('/')[:-1]), 'test' + str(i) + '.iter1.nii.gz') try: load_nii(outputname) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + ' Patient ' + patient[0].rsplit('/')[-2] + ' already done' + c['nc']) except IOError: print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + ' Testing with patient ' + c['b'] + patient[0].rsplit('/')[-2] + c['nc']) image_nii = load_nii(patient[0]) image = np.zeros_like(image_nii.get_data()) print(' 0% of data tested', end='\r') for batch, centers, percent in load_patch_batch_percent(patient, 100000, patch_size): y_pred = net.predict_proba(batch) print(' %f%% of data tested' % percent, end='\r') [x, y, z] = np.stack(centers, axis=1) image[x, y, z] = y_pred[:, 1] print(c['g'] + ' -- Saving image ' + c['b'] + outputname + c['nc']) image_nii.get_data()[:] = image image_nii.to_filename(outputname) ''' Here we perform the last iteration ''' print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Running iteration ' + c['b'] + '2' + c['nc'] + c['g'] + '>' + c['nc']) outputname2 = os.path.join(path, 'test' + str(i) + '.old.iter2.nii.gz') if options['old'] \ else os.path.join(path, 'test' + str(i) + '.new.iter2.nii.gz') net_name = os.path.join(path, 'deep-challenge2016.final.old.') if options['old'] \ else os.path.join(path, 'deep-challenge2016.final.new.') net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, on_epoch_finished=[ SaveWeights(net_name + 'model_weights.pkl', only_best=True, pickle=False), EarlyStopping(patience=50) ], batch_iterator_train=BatchIterator(batch_size=4096), verbose=10, max_epochs=2000, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum((p + t[:, 1])))], ) try: net.load_params_from(net_name + 'model_weights.pkl') except IOError: print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + 'Loading the data for ' + c['b'] + 'iteration 2' + c['nc']) names_lou = np.concatenate([names[:, :i], names[:, i + 1:]], axis=1) paths = ['/'.join(name.rsplit('/')[:-1]) for name in names_lou[0, :]] roi_names = [os.path.join(p_path, 'test' + str(i) + '.iter1.nii.gz') for p_path in paths] mask_names = [os.path.join(p_path, 'Consensus.nii.gz') for p_path in paths] x_train, y_train = load_iter2_data( names_lou=names_lou, mask_names=mask_names, roi_names=roi_names, patch_size=patch_size, seed=seed, old=options['old'] ) print(' Training vector shape = (' + ','.join([str(length) for length in x_train.shape]) + ')') print(' Training labels shape = (' + ','.join([str(length) for length in y_train.shape]) + ')') print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + 'Training (' + c['b'] + 'final' + c['nc'] + c['g'] + ')' + c['nc']) net.fit(x_train, y_train) try: image_nii = load_nii(outputname2) image2 = image_nii.get_data() except IOError: print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Creating the probability map ' + c['b'] + '2' + c['nc'] + c['g'] + '>' + c['nc']) image_nii = load_nii(flair_name) image2 = np.zeros_like(image_nii.get_data()) print(' 0% of data tested', end='\r') sys.stdout.flush() for batch, centers, percent in load_patch_batch_percent(names_test, batch_size, patch_size): y_pred = net.predict_proba(batch) print(' %f%% of data tested' % percent, end='\r') sys.stdout.flush() [x, y, z] = np.stack(centers, axis=1) image2[x, y, z] = y_pred[:, 1] image_nii.get_data()[:] = image2 image_nii.to_filename(outputname2) image = (image1 * image2) > 0.5 seg = np.roll(np.roll(image, 1, axis=0), 1, axis=1) image_nii.get_data()[:] = seg outputname_final = os.path.join(path, 'test' + str(i) + '.old.final.nii.gz') if options['old'] \ else os.path.join(path, 'test' + str(i) + '.new.final.nii.gz') image_nii.to_filename(outputname_final) gt = load_nii(os.path.join(path, 'Consensus.nii.gz')).get_data().astype(dtype=np.bool) dsc = np.sum(2.0 * np.logical_and(gt, seg)) / (np.sum(gt) + np.sum(seg)) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<DSC value for ' + c['c'] + case + c['g'] + ' = ' + c['b'] + str(dsc) + c['nc'] + c['g'] + '>' + c['nc'])
def train_tupac(params_dict): global lookup, proba_before, proba_after, overlap ### CONSTANTS ### SIZE = params_dict['size'] PATCH_SIZE = params_dict['patch_size'] PATCH_GAP = int(PATCH_SIZE / 2) RADIUS = params_dict['radius'] normalization = params_dict['normalization'] net_name = params_dict['net_name'] print("PATCH_SIZE: ", PATCH_SIZE) print("Network name: ", net_name) N = params_dict['N'] MN = params_dict['MN'] K = params_dict['K'] EPOCHS = params_dict['epochs'] DECAY = params_dict['decay'] KGROWTH = params_dict['kgrowth'] EGROWTH = params_dict['egrowth'] VALID = 4000 def inbounds(x, y): return x < SIZE - PATCH_SIZE and x > PATCH_SIZE and y < SIZE - PATCH_SIZE and y > PATCH_SIZE def totuple(a): try: return tuple(totuple(i) for i in a) except TypeError: return a def tolist(a): try: return list(totuple(i) for i in a) except TypeError: return a ### TODO 1: READ ALL DATA ### ## Final result: coords contains indexed coords of all mitotic cells ## print("\n\nData Reading.") img = [] img_aux = [] coords = [] total_coords = [] cnt = 0 print("\nReading in original image files:") for imgfile in glob.iglob("data/train_tupac/*.jpg"): print("\n" + imgfile, end="") annotfile = imgfile[:-3] + "csv" img_vals = plt.imread(imgfile) if normalization: cntr = Controller(img) img_norm, _, __, __ = macenko(cntr) img.append(img_norm) else: img.append(img_vals) csvReader = csv.reader(open(annotfile, 'rb')) for row in csvReader: minx, miny, maxx, maxy = (SIZE, SIZE, 0, 0) random_coords = [] for i in range(0, len(row) / 2): xv, yv = (int(row[2 * i]), int(row[2 * i + 1])) if xv > PATCH_SIZE / 2 + 1 and yv > PATCH_SIZE / 2 + 1 and xv < SIZE - PATCH_SIZE / 2 - 1 and yv < SIZE - PATCH_SIZE / 2 - 1: coords.append((yv, xv, cnt)) total_coords.append((yv, xv, cnt)) cnt += 1 print("\n") print('Num images: ', len(img)) print(len(coords)) print('not synthesizing image through reflection') def get_patches(coords, patchsize=PATCH_SIZE): patches = np.zeros((len(coords), patchsize, patchsize, 3)) i = 0 for (x, y, img_num) in coords: #print x, y #print (x - patchsize/2), (x + patchsize/2 + 1), (y - patchsize/2), (y + patchsize/2 + 1) patches[i] = img[img_num, (x - patchsize / 2):(x + patchsize / 2 + 1), (y - patchsize / 2):(y + patchsize / 2 + 1), :] patches[i] = np.divide(patches[i], 255.0) i += 1 return patches ### TODO 2: CREATE AND DESIGN CNN #### ## Final result: nn contains desired CNN ## print("\n\nCreating and Designing CNN.") def roc_robust(y_true, y_proba): if sum(y_true) == 0 or sum(y_true) == len(y_true): return 0.0 else: return roc_auc_score(y_true, y_proba) print("Building Image Perturbation Models/Callbacks:") train_iterator_mixins = [ RandomFlipBatchIteratorMixin, AffineTransformBatchIteratorMixin, #MeanSubtractBatchiteratorMixin ] TrainIterator = make_iterator('TrainIterator', train_iterator_mixins) test_iterator_mixins = [ RandomFlipBatchIteratorMixin, #MeanSubtractBatchiteratorMixin ] TestIterator = make_iterator('TestIterator', test_iterator_mixins) mean_value = np.mean(np.mean(np.mean(img))) train_iterator_kwargs = { 'batch_size': 20, 'affine_p': 0.5, 'affine_scale_choices': np.linspace(start=0.85, stop=1.6, num=10), 'flip_horizontal_p': 0.5, 'flip_vertical_p': 0.5, 'affine_translation_choices': np.arange(-5, 6, 1), 'affine_rotation_choices': np.linspace(start=-30.0, stop=30.0, num=20), #'mean': mean_value, } train_iterator_tmp = TrainIterator(**train_iterator_kwargs) test_iterator_kwargs = { 'batch_size': 20, 'flip_horizontal_p': 0.5, 'flip_vertical_p': 0.5, #'mean': mean_value, } test_iterator_tmp = TestIterator(**test_iterator_kwargs) def color_transform(image): if random.uniform(0.0, 1.0) < 0.15: image[0] = np.multiply(image[0], random.uniform(0.95, 1.05)) if random.uniform(0.0, 1.0) < 0.15: image[1] = np.multiply(image[1], random.uniform(0.95, 1.05)) if random.uniform(0.0, 1.0) < 0.15: image[2] = np.multiply(image[2], random.uniform(0.95, 1.05)) return np.clip(image, -1.0, 1.0).astype(np.float32) radius = PATCH_GAP kernel = np.zeros((2 * radius + 1, 2 * radius + 1)) y, x = np.ogrid[-radius:radius + 1, -radius:radius + 1] mask = x**2 + y**2 >= radius**2 class CustomBatchIterator(BatchIterator): def __init__(self, batch_size, built_iterator): super(CustomBatchIterator, self).__init__(batch_size=batch_size) self.iter = built_iterator def transform(self, Xb, yb): Xb = get_patches(Xb) Xb = Xb.astype(np.float32).swapaxes(1, 3) for i in range(0, len(yb)): Xb[i] = color_transform(Xb[i]) for c in range(0, 3): Xb[i, c][mask] = 0.0 yb = yb.astype(np.uint8) Xb, yb = self.iter.transform(Xb, yb) #for i in range(0, len(yb)): # plt.imsave("img" + str(yb[i]) + "num" + str(i) + ".png", Xb[i].swapaxes(0, 2)) return Xb, yb train_iterator = CustomBatchIterator(batch_size=20, built_iterator=train_iterator_tmp) test_iterator = CustomBatchIterator(batch_size=20, built_iterator=test_iterator_tmp) # Model Specifications net = phf.build_GoogLeNet(PATCH_SIZE, PATCH_SIZE) ### TODO 3: DEFINE METHODS TO WORK WITH NORMAL_STACKS ### ## Final result: update_stack(stack, times) ### proba_before = 0.0 proba_after = 0.0 overlap = 0.0 def prob(coord, net): patch = get_patches([coord]).swapaxes(1, 3).astype(np.float32) patch2 = patch.swapaxes(2, 3) saved_iter = net.batch_iterator_test net.batch_iterator_test = test_iterator_tmp prob = net.predict_proba(patch)[0, 1] prob2 = net.predict_proba(patch2)[0, 1] net.batch_iterator_test = saved_iter return (prob + prob2) / 2.0 def create_stack(length): global lookup normal_stack = [] while len(normal_stack) < length: triple = (random.randint(PATCH_SIZE / 2, SIZE - PATCH_SIZE / 2 - 1), random.randint(PATCH_SIZE / 2, SIZE - PATCH_SIZE / 2 - 1), random.randint(-len(img_aux), len(img) - 1)) if triple not in lookup: normal_stack.append(triple) lookup.add(triple) return normal_stack def update_stack(normal_stack, iters, net): global lookup, proba_before, proba_after, overlap init_len = len(normal_stack) probs = [] for i in range(0, len(normal_stack)): probs.append(prob(normal_stack[i], net)) proba_before = np.mean(probs) for i in range(0, iters): triple = (random.randint(PATCH_SIZE / 2, SIZE - PATCH_SIZE / 2 - 1), random.randint(PATCH_SIZE / 2, SIZE - PATCH_SIZE / 2 - 1), random.randint(-len(img_aux), len(img) - 1)) if triple not in lookup: normal_stack.append(triple) probs.append(prob(triple, net)) lookup.add(triple) sort_idx = np.argsort(probs)[::-1] normal_stack = np.array(normal_stack)[sort_idx, :] normal_stack = normal_stack[0:init_len] normal_stack = tolist(normal_stack) probs = np.array(probs) probs = probs[sort_idx] probs = probs[0:init_len] proba_after = np.mean(probs) overlap = 0.0 for i in sort_idx[0:init_len]: if i < init_len: overlap += 1.0 overlap /= init_len return normal_stack lookup = set(total_coords) coords = shuffle(coords) valid_sample_mitosis = coords[0:(VALID / 2)] coords = coords[(VALID / 2):(len(coords))] valid_sample_normal = create_stack(VALID / 2) valid_sample = valid_sample_mitosis + valid_sample_normal valid_sample_y = np.append(np.ones(VALID / 2), np.zeros(VALID / 2)) lookup = set(np.append(total_coords, valid_sample_normal)) def get_validation(train_X, train_y, net): return train_X, valid_sample, train_y, valid_sample_y nn = NeuralNet( net['softmax'], max_epochs=1, update=adam, update_learning_rate=.0001, #start with a really low learning rate #objective_l2=0.0001, # batch iteration params batch_iterator_train=train_iterator, batch_iterator_test=test_iterator, train_split=get_validation, verbose=3, ) ### TODO 4: Train network on normal stacks ### ## Final result: done! ### #print('\nLoading Data from Previous Network') #nn.load_params_from("cachedgooglenn2.params") print("\n\nTraining Network!") normal_stack = create_stack(N) print("Made stack!") for k in range(0, 1000): saved_accuracy = 10011.0 print("Length of coords:", len(coords), "length of sample", MN) data = np.array(normal_stack + random.sample(coords, MN)) val = np.append(np.zeros(N), np.ones(MN)) data, val = shuffle(data, val) for i in range(0, int(EPOCHS)): nn.fit(data, val) cur_accuracy = nn.train_history_[-1]['valid_loss'] if cur_accuracy - 0.004 > saved_accuracy: print("Test Loss Jump! Loading previous network!") with suppress_stdout(): nn.load_params_from("data/" + str(net_name) + ".params") else: nn.save_params_to("data/" + net_name + ".params") saved_accuracy = cur_accuracy nn.update_learning_rate *= DECAY normal_stack = update_stack(normal_stack, int(K * N), nn) print( "Data Report: K={3:.2f}, Prob Before={0}, Prob After={1}, Overlap={2}" .format(proba_before, proba_after, overlap, K)) accuracy = nn.train_history_[-1]['valid_accuracy'] nn.save_params_to('checkpoints/' + str(net_name) + '-checkpoint' + str(k) + '-validacc' + str(accuracy) + '.params') K += KGROWTH EPOCHS *= EGROWTH for r in range(len(nn.train_history_)): nn.train_history_[r]['train_loss'] = 10011.0 nn.save_params_to("data/" + str(net_name) + ".params")
def main(): seed = 12345 np.random.seed(seed) set_lasagne_rng(RandomState(seed)) LOOKUP_PATH = os.path.join(WDIR, 'data', 'HIV.pkl') lookup = pickle.load(open(LOOKUP_PATH, 'rb')) data_list = lookup['data'] y = lookup['y'] labels = lookup['labels'] nmark = len(labels) # event occurence list occurred = [x for i, x in enumerate(data_list) if y[i, 1] == 1] not_occurred = [x for i, x in enumerate(data_list) if y[i, 1] == 0] y1 = y[y[:, 1] == 1] y0 = y[y[:, 1] == 0] # split the examples randomly into a training (2/3) and test (1/3) cohort # both cohorts should contain equal percentage of cencored data sep1 = len(y1) / 3 sep0 = len(y0) / 3 # include only uncensored data from the training cohort for training CellCnn tr_list = occurred[sep1:] tr_stime = y1[sep1:, 0].astype(float) # transform survival times to [-1, 1] interval by ranking them tr_stime = (ss.rankdata(tr_stime) / (0.5 * len(tr_stime))) - 1 # fit scaler to all training data sc = StandardScaler() sc.fit(np.vstack(occurred[sep1:] + not_occurred[sep0:])) tr_list = [sc.transform(x) for x in tr_list] # the test cohort validation_list = [ sc.transform(x) for x in (occurred[:sep1] + not_occurred[:sep0]) ] y_valid = np.vstack([y1[:sep1], y0[:sep0]]) # cross validation on the training cohort nfold = 10 nfilter = 3 skf = KFold(len(tr_list), n_folds=nfold, shuffle=True) committee = [] valid_accuracy = [] accum_w = np.empty((nfilter * nfold, nmark + 2)) for ifold, (train_index, test_index) in enumerate(skf): cv_train_samples = [tr_list[t_idx] for t_idx in train_index] cv_test_samples = [tr_list[t_idx] for t_idx in test_index] cv_y_train = list(tr_stime[train_index]) cv_y_test = list(tr_stime[test_index]) results = train_model(cv_train_samples, cv_y_train, labels, valid_samples=cv_test_samples, valid_phenotypes=cv_y_test, ncell=500, nsubset=200, subset_selection='random', nrun=3, pooling='mean', regression=True, nfilter=nfilter, learning_rate=0.03, momentum=0.9, l2_weight_decay_conv=1e-8, l2_weight_decay_out=1e-8, max_epochs=20, verbose=1, select_filters='best', accur_thres=-1) net_dict = results['best_net'] # update the committee of networks committee.append(net_dict) valid_accuracy.append(results['best_accuracy']) w_tot = param_vector(net_dict, regression=True) # add weights to accumulator accum_w[ifold * nfilter:(ifold + 1) * nfilter] = w_tot save_path = os.path.join(OUTDIR, 'network_committee.pkl') with open(save_path, 'wb') as f: pickle.dump((committee, valid_accuracy), f, -1) ''' committee, valid_accuracy = pickle.load(open(save_path, 'r')) # retrieve the filter weights for ifold, net_dict in enumerate(committee): w_tot = param_vector(net_dict, regression=True) # add weights to accumulator accum_w[ifold*nfilter:(ifold+1)*nfilter] = w_tot ''' # choose the strong signatures (all of them) w_strong = accum_w # members of each cluster should have cosine similarity > 0.7 # equivalently, cosine distance < 0.3 Z = linkage(w_strong, 'average', metric='cosine') clusters = fcluster(Z, .3, criterion='distance') - 1 n_clusters = len(np.unique(clusters)) print '%d clusters chosen' % (n_clusters) # plot the discovered filter profiles plt.figure(figsize=(3, 2)) idx = range(nmark) + [nmark + 1] clmap = sns.clustermap(pd.DataFrame(w_strong[:, idx], columns=labels + ['survival']), method='average', metric='cosine', row_linkage=Z, col_cluster=False, robust=True, yticklabels=clusters) clmap.cax.set_visible(False) fig_path = os.path.join(OUTDIR, 'HIV_clmap.eps') clmap.savefig(fig_path, format='eps') plt.close() # generate the consensus filter profiles c = Counter(clusters) cons = [] for key, val in c.items(): if val > nfold / 2: cons.append(np.mean(w_strong[clusters == key], axis=0)) cons_mat = np.vstack(cons) # plot the consensus filter profiles plt.figure(figsize=(10, 3)) idx = range(nmark) + [nmark + 1] ax = sns.heatmap(pd.DataFrame(cons_mat[:, idx], columns=labels + ['survival']), robust=True, yticklabels=False) plt.xticks(rotation=90) ax.tick_params(axis='both', which='major', labelsize=20) plt.tight_layout() fig_path = os.path.join(OUTDIR, 'clmap_consensus.eps') plt.savefig(fig_path, format='eps') plt.close() # create an ensemble of neural networks ncell_cons = 3000 ncell_voter = 3000 layers_voter = [(layers.InputLayer, { 'name': 'input', 'shape': (None, nmark, ncell_voter) }), (layers.Conv1DLayer, { 'name': 'conv', 'num_filters': nfilter, 'filter_size': 1 }), (layers.Pool1DLayer, { 'name': 'meanPool', 'pool_size': ncell_voter, 'mode': 'average_exc_pad' }), (layers.DenseLayer, { 'name': 'output', 'num_units': 1, 'nonlinearity': T.tanh })] # predict on the test cohort small_data_list_v = [ x[:ncell_cons].T.reshape(1, nmark, ncell_cons) for x in validation_list ] data_v = np.vstack(small_data_list_v) stime, censor = y_valid[:, 0], y_valid[:, 1] # committee of the best nfold/2 models voter_risk_pred = list() for ifold in np.argsort(valid_accuracy): voter = NeuralNet(layers=layers_voter, update=nesterov_momentum, update_learning_rate=0.001, regression=True, max_epochs=5, verbose=0) voter.load_params_from(committee[ifold]) voter.initialize() # rank the risk predictions voter_risk_pred.append(ss.rankdata(-np.squeeze(voter.predict(data_v)))) all_voters = np.vstack(voter_risk_pred) # compute mean rank per individual risk_p = np.mean(all_voters, axis=0) g1 = np.squeeze(risk_p > np.median(risk_p)) voters_pval_v = logrank_pval(stime, censor, g1) fig_v = os.path.join(OUTDIR, 'cellCnn_cox_test.eps') plot_KM(stime, censor, g1, voters_pval_v, fig_v) # filter-activating cells data_t = np.vstack(small_data_list_v) data_stack = np.vstack([x for x in np.swapaxes(data_t, 2, 1)]) # finally define a network from the consensus filters nfilter_cons = cons_mat.shape[0] ncell_cons = 3000 layers_cons = [(layers.InputLayer, { 'name': 'input', 'shape': (None, nmark, ncell_cons) }), (layers.Conv1DLayer, { 'name': 'conv', 'b': init.Constant(cons_mat[:, -2]), 'W': cons_mat[:, :-2].reshape(nfilter_cons, nmark, 1), 'num_filters': nfilter_cons, 'filter_size': 1 }), (layers.Pool1DLayer, { 'name': 'meanPool', 'pool_size': ncell_cons, 'mode': 'average_exc_pad' }), (layers.DenseLayer, { 'name': 'output', 'num_units': 1, 'W': np.sign(cons_mat[:, -1:]), 'b': init.Constant(0.), 'nonlinearity': T.tanh })] net_cons = NeuralNet(layers=layers_cons, update=nesterov_momentum, update_learning_rate=0.001, regression=True, max_epochs=5, verbose=0) net_cons.initialize() # get the representation after mean pooling xs = T.tensor3('xs').astype(theano.config.floatX) act_conv = theano.function([xs], lh.get_output(net_cons.layers_['conv'], xs)) # and apply to the test data act_tot = act_conv(data_t) act_tot = np.swapaxes(act_tot, 2, 1) act_stack = np.vstack([x for x in act_tot]) idx = range(7) + [8, 9] for i_map in range(nfilter_cons): val = act_stack[:, i_map] descending_order = np.argsort(val)[::-1] val_cumsum = np.cumsum(val[descending_order]) data_sorted = data_stack[descending_order] thres = 0.75 * val_cumsum[-1] res_data = data_sorted[val_cumsum < thres] fig_path = os.path.join(OUTDIR, 'filter_' + str(i_map) + '_active.eps') plot_marker_distribution([res_data[:, idx], data_stack[:, idx]], ['filter ' + str(i_map), 'all'], [labels[l] for l in idx], (3, 3), fig_path, 24)
class CNN: def __init__(self,subject): self.convnet = NeuralNet(layers=[]) self.subject = subject def make_cnn(self,X,y): #FSIZE = (int(np.floor(X.shape[2])), int(np.floor(X.shape[3]/4))) #FSIZE3 = (2,2) NUM_FILTERS1 = 16 NUM_FILTERS2 = 32 NUM_FILTERS3 = 256 FSIZE1 = (X.shape[2],1) FSIZE2 = (NUM_FILTERS1,2) FSIZE3 = (NUM_FILTERS2,3) #x = theano.tensor.tensor4() #ax = theano.tensor.scalar() # geom_mean = theano.function( # [x,axis = 3], # theano.tensor.exp(theano.tensor.mean(theano.tensor.log(x), axis=axis, dtype='float32')) # ) # l2_norm = theano.function( # [x,axis = 3], # x.norm(2,axis=axis) # ) def geom_mean(x,axis=None): # x = theano.tensor.as_tensor_variable(x) # log = theano.tensor.log(x) # m = theano.tensor.mean(log,axis=axis) # g = m log = np.log(x) m = log.mean(axis = axis) g = np.exp(m) #g = theano.tensor.exp(m) #g = theano.tensor.exp(theano.tensor.mean(theano.tensor.log(x), axis=axis)) print "gmean",g.type,g return g def l2_norm(x,axis=None): x = theano.tensor.as_tensor_variable(x) s = theano.tensor.sum(x,axis=axis) #l = x.norm(2, axis=axis) print "norm",l.type,l return l def me(x,axis=None): x = theano.tensor.as_tensor_variable(x) m = theano.tensor.mean(x,axis=axis) print "mean",m.type,m return m #print type(theano.tensor.mean),type(geom_mean),type(l2_norm) #learning_rate = 0.0001 #learning_rate = 0.0005 #learning_rate = .001 learning_rate = .00001 # if 'pat' in self.subject: # learning_rate = 0.0001 #FSIZE1 = (1, 2) #FSIZE2 = (1, X.shape[3]) convnet = NeuralNet( layers = [ (InputLayer,{'shape' : (None,1 , X.shape[2],X.shape[3])}), (Conv2DLayer,{'num_filters' : NUM_FILTERS1, 'filter_size' : FSIZE1}), (DropoutLayer,{'p' : .75}), (ReshapeLayer,{'shape' : ([0],[2],[1],[3])}), (Conv2DLayer,{'name': 'conv2', 'num_filters' : NUM_FILTERS2, 'filter_size' : FSIZE2}), #(DropoutLayer,{'p' : .85}), #(ReshapeLayer,{'shape' : ([0],[2],[1],[3])}), #(Conv2DLayer,{'name' : 'conv3', 'num_filters' : NUM_FILTERS3, 'filter_size' : FSIZE3}), (GlobalPoolLayer,{'name' : 'g1', 'incoming' : 'conv2','pool_function' : me }), (GlobalPoolLayer,{'name' : 'g2', 'incoming' : 'conv2','pool_function' : theano.tensor.max }), (GlobalPoolLayer,{'name' : 'g3', 'incoming' : 'conv2','pool_function' : theano.tensor.min }), (GlobalPoolLayer,{'name' : 'g4', 'incoming' : 'conv2','pool_function' : theano.tensor.var }), #(GlobalPoolLayer,{'name' : 'g5', 'incoming' : 'conv2','pool_function' : geom_mean}), #(GlobalPoolLayer,{'name' : 'g6', 'incoming' : 'conv2','pool_function' : l2_norm }), (ConcatLayer,{'incomings' : ['g1','g2','g3','g4']}),#]}),# (DenseLayer, {'num_units': 256}), (DropoutLayer,{'p':.5}), (DenseLayer, {'num_units': 256}), (DenseLayer, {'num_units': 2, 'nonlinearity': softmax}), ], update_learning_rate=theano.shared(float32(learning_rate)), update_momentum=theano.shared(float32(0.9)), verbose=1, max_epochs = 100000, on_epoch_finished=[ EarlyStopping(patience=100) ], ) return convnet def fit(self,X,y,xt,yt): X,y,xt,yt = formatData(X,y=y,Xt=xt,yt=yt) self.convnet = self.make_cnn(X,y) print "shape",X.shape self.convnet.fit(X,y,xt,yt) def predict_proba(self,X): X,_,_,_ = formatData(X) return self.convnet.predict_proba(X) def predict(self,X): X,_,_,_ = formatData(X) return self.convnet.predict(X) def get_params(self,deep): return self.convnet.get_params() def load_params_from(self,net): return self.convnet.load_params_from(net)
regression=False, objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=1e-3, batch_iterator_train=train_iterator, batch_iterator_test=test_iterator, on_epoch_finished=[ save_weights, save_training_history, plot_training_history, early_stopping ], verbose=10, max_epochs=100 ) if __name__ == '__main__': X_train, X_test, y_train, y_test = load_data(test_size=0.25, random_state=42) net.fit(X_train, y_train) # Load the best weights from pickled model net.load_params_from('./examples/mnist/model_weights.pkl') score = net.score(X_test, y_test) print 'Final score %.4f' % score
def build_dbn(): cols = ['Start'] t = 1 channels = 14 batch_size = None #None = arbitary batch size hidden_layer_size = 100 #change to 1024 N_EVENTS = 1 max_epochs = 100 NO_TIME_POINTS = 70 #311 ids_tot = [] pred_tot = [] test_dict = dict() test_total = 0 X, y = load_dataset() X_test, ids_tot, test_dict, test_total = load_testdata() net = NeuralNet( layers=[ ('input', layers.InputLayer), ('dropout1', layers.DropoutLayer), ('conv1', layers.Conv1DLayer), ('conv2', layers.Conv1DLayer), ('pool1', layers.MaxPool1DLayer), ('dropout2', layers.DropoutLayer), ('hidden4', layers.DenseLayer), ('dropout3', layers.DropoutLayer), ('hidden5', layers.DenseLayer), ('dropout4', layers.DropoutLayer), ('output', layers.DenseLayer), ], input_shape=(None, channels, NO_TIME_POINTS), dropout1_p=0.5, conv1_num_filters=4, conv1_filter_size=1, conv2_num_filters=8, conv2_filter_size=4, pool1_pool_size=4, dropout2_p=0.5, hidden4_num_units=hidden_layer_size, dropout3_p=0.5, hidden5_num_units=hidden_layer_size, dropout4_p=0.5, output_num_units=N_EVENTS, output_nonlinearity=sigmoid, batch_iterator_train = BatchIterator(batch_size=1000), batch_iterator_test = BatchIterator(batch_size=1000), y_tensor_type=theano.tensor.matrix, update=nesterov_momentum, update_learning_rate=theano.shared(float(0.03)), update_momentum=theano.shared(float(0.9)), objective_loss_function=loss, regression=True, max_epochs=max_epochs, verbose=1, ) ###process training data#### X = data_preprocess(X) total_time_points = len(X) // NO_TIME_POINTS no_rows = total_time_points * NO_TIME_POINTS print X.shape print total_time_points print no_rows X = X[0:no_rows, :] print X.shape X = X.transpose() X_Samples = np.split(X, total_time_points, axis=1) X = np.asarray(X_Samples) print X.shape y = y[0:no_rows, :] y = y[::NO_TIME_POINTS, :] print("Training trial %d...." %(t)) net.fit(X,y) ####process test data#### print("Creating prediction file ... ") X_test = X_test X_test = data_preprocess(X_test) total_test_time_points = len(X_test) // NO_TIME_POINTS remainder_test_points = len(X_test) % NO_TIME_POINTS no_rows = total_test_time_points * NO_TIME_POINTS X_test = X_test[0:no_rows, :] X_test = X_test.transpose() X_test_Samples = np.split(X_test, total_test_time_points, axis=1) X_test = np.asarray(X_test_Samples) ########################################################################### #######get predictions and write to files for series 9 and series 10####### print("Testing subject 0....") params = net.get_all_params_values() learned_weights = net.load_params_from(params) probabilities = net.predict_proba(X_test) total_time_points = [] all_remainder_data = [] subs = [] total_test_points = 0 trials = np.array(['01','02','03','04','05','06','07','08','09','10']) for trial in trials: sub = 'subj{0}_series{1}'.format('0', trial) data_len = test_dict[sub] total_time_point = data_len // NO_TIME_POINTS remainder_data = data_len % NO_TIME_POINTS subs.append(sub) total_time_points.append(total_time_point) all_remainder_data.append(remainder_data) total_test_points = np.sum(total_time_points) print len(ids_tot) print cols print len(probabilities) for i, p in enumerate(probabilities): for j in range(NO_TIME_POINTS): pred_tot.append(p) print len(pred_tot) # for k in range(np.sum(all_remainder_data)): # pred_tot.append(pred_tot[-1]) #submission file print('Creating submission(prediction) file...') submission_file = './test_conv_net_push.csv' # create pandas object for sbmission submission = pd.DataFrame(index=ids_tot[:len(pred_tot)], columns=cols, data=pred_tot) # write file submission.to_csv(submission_file, index_label='id', float_format='%.6f')
import sys sys.setrecursionlimit(10000) X = None y = None if os.path.exists('X.pickle') and os.path.exists('y.pickle'): X = pickle.load(open('X.pickle', 'rb')) y = pickle.load(open('y.pickle', 'rb')) else: X, y = load2d() with open('X.pickle', 'wb') as f: pickle.dump(X, f, -1) with open('y.pickle', 'wb') as f: pickle.dump(y, f, -1) if os.path.exists('net.pickle'): print 'already learning end' elif os.path.exists('net_epoch_backup.pickle'): net.load_params_from('net_epoch_backup.pickle') net.fit(X, y) else: net.fit(X, y) if net is not None: with open('net.pickle', 'wb') as f: pickle.dump(y, f, -1)
normal_stack = create_stack(N) print("Made stack!") for k in range(0, 1000): saved_accuracy = 10011.0 data = np.array(normal_stack + random.sample(coords, N)) val = np.append(np.zeros(N), np.ones(N)) data, val = shuffle(data, val) for i in range(0, int(EPOCHS)): nn.fit(data, val) cur_accuracy = nn.train_history_[-1]['valid_loss'] if cur_accuracy - 0.004 > saved_accuracy: print("Test Loss Jump! Loading previous network!") with suppress_stdout(): nn.load_params_from("cachedgooglenn2.params") else: nn.save_params_to('cachedgooglenn2.params') saved_accuracy = cur_accuracy nn.update_learning_rate *= DECAY normal_stack = update_stack(normal_stack, int(K*N), nn) print("Data Report: K={3:.2f}, Prob Before={0}, Prob After={1}, Overlap={2}".format(proba_before, proba_after, overlap, K)) K += KGROWTH EPOCHS *= EGROWTH for r in range(len(nn.train_history_)): nn.train_history_[r]['train_loss'] = 10011.0 nn.save_params_to('googlenn2.params')
def build_dbn(): cols = ['Start'] t = 1 channels = 14 batch_size = None #None = arbitary batch size hidden_layer_size = 100 N_EVENTS = 1 max_epochs = 500 NO_TIME_POINTS = 177 ids_tot = [] pred_tot = [] test_dict = dict() test_total = 0 net = NeuralNet( layers=[ ('input', layers.InputLayer), ('conv1', layers.Conv1DLayer), ('conv2', layers.Conv1DLayer), ('pool1', layers.MaxPool1DLayer), ('dropout2', layers.DropoutLayer), ('hidden4', layers.DenseLayer), ('dropout3', layers.DropoutLayer), ('hidden5', layers.DenseLayer), ('dropout4', layers.DropoutLayer), ('output', layers.DenseLayer), ], input_shape=(batch_size, channels, NO_TIME_POINTS), conv1_num_filters=4, conv1_filter_size=1, conv1_nonlinearity=None, conv2_num_filters=8, conv2_filter_size=5, pool1_pool_size=4, dropout2_p=0.5, hidden4_num_units=hidden_layer_size, dropout3_p=0.3, hidden5_num_units=hidden_layer_size, dropout4_p=0.2, output_num_units=N_EVENTS, output_nonlinearity=sigmoid, batch_iterator_train = BatchIterator(batch_size=1000), batch_iterator_test = BatchIterator(batch_size=1000), y_tensor_type=theano.tensor.matrix, update=nesterov_momentum, update_learning_rate=theano.shared(float(0.03)), update_momentum=theano.shared(float(0.9)), objective_loss_function=loss, regression=True, on_epoch_finished=[ AdjustVariable('update_learning_rate', start=0.03,stop=0.0001), AdjustVariable('update_momentum', start=0.9, stop=0.999), EarlyStopping(patience=100), ], max_epochs=max_epochs, verbose=1, ) # load trial dataset dic = pickle.load(open('datapickled/traildata.pickle', 'rb')) X = dic['X'] y = dic['y'] # process training data total_time_points = len(X) // NO_TIME_POINTS no_rows = total_time_points * NO_TIME_POINTS X = X[0:no_rows, :] X = X.transpose() X_Samples = np.split(X, total_time_points, axis=1) X = np.asarray(X_Samples) y = y[0:no_rows, :] y = y[::NO_TIME_POINTS, :] y = y.astype('float32') net.fit(X,y) tip = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") # Save the net with open('net/net'+tip+'.pickle', 'wb') as f: pickle.dump(net, f, -1) plot(net) # Load test data dic = pickle.load(open('datapickled/testdata2.pickle', 'rb')) X_test = dic['X_test'] ids_tot = dic['ids_tot'] test_dict = dic['test_dict'] test_total = dic['test_total'] ####process test data#### print("Creating prediction file ... ") X_test = X_test total_test_len = len(X_test) total_test_time_points = len(X_test) // NO_TIME_POINTS remainder_test_points = len(X_test) % NO_TIME_POINTS no_rows = total_test_time_points * NO_TIME_POINTS X_test = X_test[0:no_rows, :] X_test = X_test.transpose() X_test_Samples = np.split(X_test, total_test_time_points, axis=1) X_test = np.asarray(X_test_Samples) # Evaluate test data print("Testing subject 0....") params = net.get_all_params_values() learned_weights = net.load_params_from(params) probabilities = net.predict_proba(X_test) total_test_points = total_test_len // NO_TIME_POINTS remainder_data = total_test_len % NO_TIME_POINTS for i, p in enumerate(probabilities): if i != total_test_points: for j in range(NO_TIME_POINTS): pred_tot.append(p) # create prediction file print('Creating submission(prediction) file...') tip = datetime.now().strftime("%Y-%m-%d-%H-%M-%S") submission_file = 'res/test_conv_net_push'+tip+'.csv' # create pandas object submission = pd.DataFrame(index=ids_tot[:len(pred_tot)],columns=cols,data=pred_tot) # write file submission.to_csv(submission_file, index_label='id', float_format='%.6f')
"""Loading data and training Lasagne network using nolearn""" trainVal2 = trainVal2 print trainImg2.shape print "Ratio: " + str(1.0 - float(sum(trainVal2)) / float(len(trainVal2))) best_accuracy = 0.0 print "Training Classifier: 80/20 split" for i in [1, 2, 3, 4, 6, 8, 10, 40, 100, 250]: saved_accuracy = 0.0 print "Size: " + str(i*2000) for epoch in range(0, 25): nn = nn.fit(trainImg2[0:2000*i], trainVal2[0:2000*i]) cur_accuracy = nn.train_history_[-1]['valid_accuracy'] best_accuracy = max(cur_accuracy, best_accuracy) #print "Current Accuracy: " + str(cur_accuracy) #print "Saved Accuracy: " + str(saved_accuracy) if cur_accuracy + 0.04 < saved_accuracy or cur_accuracy + 0.12 < best_accuracy: print "Accuracy Drop! Loading previous network!" nn.load_params_from("cachednn.params") else: nn.save_params_to('cachednn.params') saved_accuracy = cur_accuracy nn.save_params_to('nn_stage2.params') #pickle.dump(nn, open( "nn_stage2.pkl", "wb" ))
def main(): c = color_codes() patch_size = (15, 15, 15) dir_name = '/home/sergivalverde/w/CNN/images/CH16' patients = [f for f in sorted(os.listdir(dir_name)) if os.path.isdir(os.path.join(dir_name, f))] names = np.stack([name for name in [ [os.path.join(dir_name, patient, 'FLAIR_preprocessed.nii.gz') for patient in patients], [os.path.join(dir_name, patient, 'DP_preprocessed.nii.gz') for patient in patients], [os.path.join(dir_name, patient, 'T2_preprocessed.nii.gz') for patient in patients], [os.path.join(dir_name, patient, 'T1_preprocessed.nii.gz') for patient in patients] ] if name is not None], axis=1) seed = np.random.randint(np.iinfo(np.int32).max) ''' Here we create an initial net to find conflictive voxels ''' print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Running iteration ' + c['b'] + '1>' + c['nc']) net_name = '/home/sergivalverde/w/CNN/code/CNN1/miccai_challenge2016/deep-challenge2016.init.' net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, on_epoch_finished=[ SaveWeights(net_name + 'model_weights.pkl', only_best=True, pickle=False), SaveTrainingHistory(net_name + 'model_history.pkl'), PlotTrainingHistory(net_name + 'training_history.png'), EarlyStopping(patience=10) ], verbose=10, max_epochs=50, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum((p + t[:, 1])))], ) try: net.load_params_from(net_name + 'model_weights.pkl') except IOError: print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + 'Loading the data for ' + c['b'] + 'iteration 1' + c['nc']) # Create the data (x, y, _) = load_patches( dir_name=dir_name, use_flair=True, use_pd=True, use_t2=True, use_t1=True, use_gado=False, flair_name='FLAIR_preprocessed.nii.gz', pd_name='DP_preprocessed.nii.gz', t2_name='T2_preprocessed.nii.gz', t1_name='T1_preprocessed.nii.gz', gado_name=None, mask_name='Consensus.nii.gz', size=patch_size ) print('-- Permuting the data') np.random.seed(seed) x_train = np.random.permutation(np.concatenate(x).astype(dtype=np.float32)) print('-- Permuting the labels') np.random.seed(seed) y_train = np.random.permutation(np.concatenate(y).astype(dtype=np.int32)) y_train = y_train[:, y_train.shape[1] / 2 + 1, y_train.shape[2] / 2 + 1, y_train.shape[3] / 2 + 1] print('-- Training vector shape = (' + ','.join([str(length) for length in x_train.shape]) + ')') print('-- Training labels shape = (' + ','.join([str(length) for length in y_train.shape]) + ')') print c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] +\ 'Training (' + c['b'] + 'initial' + c['nc'] + c['g'] + ')' + c['nc'] # We try to get the last weights to keep improving the net over and over net.fit(x_train, y_train) ''' Here we get the seeds ''' print c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Looking for seeds>' + c['nc'] for patient in names: output_name = os.path.join('/'.join(patient[0].rsplit('/')[:-1]), 'test.iter1.nii.gz') try: load_nii(output_name) print c['c'] + '[' + strftime("%H:%M:%S") + '] ' \ + c['g'] + '-- Patient ' + patient[0].rsplit('/')[-2] + ' already done' + c['nc'] except IOError: print c['c'] + '[' + strftime("%H:%M:%S") + '] '\ + c['g'] + '-- Testing with patient ' + c['b'] + patient[0].rsplit('/')[-2] + c['nc'] image_nii = load_nii(patient[0]) image = np.zeros_like(image_nii.get_data()) for batch, centers in load_patch_batch(patient, 100000, patch_size): y_pred = net.predict_proba(batch) [x, y, z] = np.stack(centers, axis=1) image[x, y, z] = y_pred[:, 1] print c['g'] + '-- Saving image ' + c['b'] + output_name + c['nc'] image_nii.get_data()[:] = image image_nii.to_filename(output_name) ''' Here we perform the last iteration ''' print c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Running iteration ' + c['b'] + '2>' + c['nc'] net_name = '/home/sergivalverde/w/CNN/code/CNN1/miccai_challenge2016/deep-challenge2016.final.' net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, on_epoch_finished=[ SaveWeights(net_name + 'model_weights.pkl', only_best=True, pickle=False), SaveTrainingHistory(net_name + 'model_history.pkl'), PlotTrainingHistory(net_name + 'training_history.png'), ], batch_iterator_train=BatchIterator(batch_size=4096), verbose=10, max_epochs=2000, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum((p + t[:, 1])))], ) try: net.load_params_from(net_name + 'model_weights.pkl') except IOError: pass print c['c'] + '[' + strftime("%H:%M:%S") + '] '\ + c['g'] + 'Loading the data for ' + c['b'] + 'iteration 2' + c['nc'] (x, y, names) = load_patches( dir_name='/home/sergivalverde/w/CNN/images/CH16', use_flair=True, use_pd=True, use_t2=True, use_t1=True, use_gado=False, flair_name='FLAIR_preprocessed.nii.gz', pd_name='DP_preprocessed.nii.gz', t2_name='T2_preprocessed.nii.gz', gado_name=None, t1_name='T1_preprocessed.nii.gz', mask_name='Consensus.nii.gz', size=patch_size, roi_name='test.iter1.nii.gz' ) print '-- Permuting the data' np.random.seed(seed) x_train = np.random.permutation(np.concatenate(x).astype(dtype=np.float32)) print '-- Permuting the labels' np.random.seed(seed) y_train = np.random.permutation(np.concatenate(y).astype(dtype=np.int32)) y_train = y_train[:, y_train.shape[1] / 2 + 1, y_train.shape[2] / 2 + 1, y_train.shape[3] / 2 + 1] print '-- Training vector shape = (' + ','.join([str(length) for length in x_train.shape]) + ')' print '-- Training labels shape = (' + ','.join([str(length) for length in y_train.shape]) + ')' print c['c'] + '[' + strftime("%H:%M:%S") + '] '\ + c['g'] + 'Training (' + c['b'] + 'final' + c['nc'] + c['g'] + ')' + c['nc'] net.fit(x_train, y_train)
], input_shape = (None, 1, 20, 20), conv_num_filters = 32, conv_filter_size = (3, 3), pool_pool_size = (2, 2), hidden_num_units = 50, output_num_units = 2, output_nonlinearity = softmax, update_learning_rate=0.01, update_momentum = 0.9, regression = False, max_epochs = 50, verbose = 1, ) net.load_params_from(CNN_Weights) ############################################################################## # Scan the entire image with a (w x h) window ############################################################################## for root, dirs, files in os.walk(SourceDir): for name in files: ext = ['.jpg', '.jpeg', '.gif', '.png'] if name.endswith(tuple(ext)): path = os.path.join(root,name) orig_image = Image.open(path).convert('RGBA') image = orig_image.convert('L') # Convert to grayscale image = ImageOps.equalize(image) # Histogram equalization
def main(): data = load_av_letters('data/allData_mouthROIs.mat') # create the necessary variable mappings data_matrix = data['dataMatrix'] data_matrix_len = data_matrix.shape[0] targets_vec = data['targetsVec'] vid_len_vec = data['videoLengthVec'] iter_vec = data['iterVec'] indexes = create_split_index(data_matrix_len, vid_len_vec, iter_vec) # split the data train_data = data_matrix[indexes == True] train_targets = targets_vec[indexes == True] test_data = data_matrix[indexes == False] test_targets = targets_vec[indexes == False] idx = [i for i, elem in enumerate(test_targets) if elem == 20] print(train_data.shape) print(test_data.shape) print(sum([train_data.shape[0], test_data.shape[0]])) # resize the input data to 40 x 30 train_data_resized = resize_images(train_data).astype(np.float32) # normalize the inputs [0 - 1] train_data_resized = normalize_input(train_data_resized, centralize=True) test_data_resized = resize_images(test_data).astype(np.float32) test_data_resized = normalize_input(test_data_resized, centralize=True) dic = {} dic['trainDataResized'] = train_data_resized dic['testDataResized'] = test_data_resized """second experiment: overcomplete sigmoid encoder/decoder, squared loss""" encode_size = 2500 sigma = 0.5 # to get tied weights in the encoder/decoder, create this shared weightMatrix # 1200 x 2000 w1, layer1 = build_encoder_layers(1200, 2500, sigma) ae1 = NeuralNet(layers=layer1, max_epochs=50, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1) load = True save = False if load: print('[LOAD] layer 1...') ae1.load_params_from('layer1.dat') else: print('[TRAIN] layer 1...') ae1.fit(train_data_resized, train_data_resized) # save params if save: print('[SAVE] layer 1...') ae1.save_params_to('layer1.dat') train_encoded1 = ae1.get_output('encoder', train_data_resized) # 12293 x 2000 w2, layer2 = build_encoder_layers(2500, 1250) ae2 = NeuralNet(layers=layer2, max_epochs=50, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1) load2 = True if load2: print('[LOAD] layer 2...') ae2.load_params_from('layer2.dat') else: print('[TRAIN] layer 2...') ae2.fit(train_encoded1, train_encoded1) save2 = False if save2: print('[SAVE] layer 2...') ae2.save_params_to('layer2.dat') train_encoded2 = ae2.get_output('encoder', train_encoded1) # 12293 x 1250 w3, layer3 = build_encoder_layers(1250, 600) ae3 = NeuralNet(layers=layer3, max_epochs=100, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1) load3 = True if load3: print('[LOAD] layer 3...') ae3.load_params_from('layer3.dat') else: ae3.fit(train_encoded2, train_encoded2) save3 = False if save3: print('[SAVE] layer 3...') ae3.save_params_to('layer3.dat') train_encoded3 = ae3.get_output('encoder', train_encoded2) # 12293 x 1250 w4, layer4 = build_bottleneck_layer(600, 100) ae4 = NeuralNet(layers=layer4, max_epochs=100, objective_loss_function=squared_error, update=adadelta, regression=True, verbose=1) load4 = False if load4: print('[LOAD] layer 4...') ae4.load_params_from('layer4.dat') else: print('[TRAIN] layer 4...') ae4.fit(train_encoded3, train_encoded3) save4 = True if save4: print('[SAVE] layer 4...') ae4.save_params_to('layer4.dat') test_enc1 = ae1.get_output('encoder', test_data_resized) test_enc2 = ae2.get_output('encoder', test_enc1) test_enc3 = ae3.get_output('encoder', test_enc2) test_enc4 = ae4.get_output('encoder', test_enc3) decoder4 = create_decoder(100, 600, w4.T) decoder4.initialize() decoder3 = create_decoder(600, 1250, w3.T) decoder3.initialize() decoder2 = create_decoder(1250, 2500, w2.T) decoder2.initialize() # initialize the net decoder1 = create_decoder(2500, 1200, w1.T) decoder1.initialize() test_dec3 = decoder4.predict(test_enc4) test_dec2 = decoder3.predict(test_dec3) test_dec1 = decoder2.predict(test_dec2) X_pred = decoder1.predict(test_dec1) # plot_loss(ae3) # plot_loss(ae2) # plot_loss(ae1) tile_raster_images(X_pred[4625:4650, :], (30, 40), (5, 5), tile_spacing=(1, 1)) plt.title('reconstructed') tile_raster_images(test_data_resized[4625:4650, :], (30, 40), (5, 5), tile_spacing=(1, 1)) plt.title('original') plt.show() """
def main(): seed = 12345 np.random.seed(seed) set_lasagne_rng(RandomState(seed)) LOOKUP_PATH = os.path.join(WDIR, 'data', 'HIV.pkl') lookup = pickle.load(open(LOOKUP_PATH, 'rb')) data_list = lookup['data'] y = lookup['y'] labels = lookup['labels'] nmark = len(labels) # event occurence list occurred = [x for i, x in enumerate(data_list) if y[i,1] == 1] not_occurred = [x for i, x in enumerate(data_list) if y[i,1] == 0] y1 = y[y[:,1] == 1] y0 = y[y[:,1] == 0] # split the examples randomly into a training (2/3) and test (1/3) cohort # both cohorts should contain equal percentage of cencored data sep1 = len(y1) / 3 sep0 = len(y0) / 3 # include only uncensored data from the training cohort for training CellCnn tr_list = occurred[sep1:] tr_stime = y1[sep1:,0].astype(float) # transform survival times to [-1, 1] interval by ranking them tr_stime = (ss.rankdata(tr_stime) / (0.5 * len(tr_stime))) - 1 # fit scaler to all training data sc = StandardScaler() sc.fit(np.vstack(occurred[sep1:] + not_occurred[sep0:])) tr_list = [sc.transform(x) for x in tr_list] # the test cohort validation_list = [sc.transform(x) for x in (occurred[:sep1] + not_occurred[:sep0])] y_valid = np.vstack([y1[:sep1], y0[:sep0]]) # cross validation on the training cohort nfold = 10 nfilter = 3 skf = KFold(len(tr_list), n_folds=nfold, shuffle=True) committee = [] valid_accuracy = [] accum_w = np.empty((nfilter * nfold, nmark+2)) for ifold, (train_index, test_index) in enumerate(skf): cv_train_samples = [tr_list[t_idx] for t_idx in train_index] cv_test_samples = [tr_list[t_idx] for t_idx in test_index] cv_y_train = list(tr_stime[train_index]) cv_y_test = list(tr_stime[test_index]) results = train_model(cv_train_samples, cv_y_train, labels, valid_samples=cv_test_samples, valid_phenotypes=cv_y_test, ncell=500, nsubset=200, subset_selection='random', nrun=3, pooling='mean', regression=True, nfilter=nfilter, learning_rate=0.03, momentum=0.9, l2_weight_decay_conv=1e-8, l2_weight_decay_out=1e-8, max_epochs=20, verbose=1, select_filters='best', accur_thres=-1) net_dict = results['best_net'] # update the committee of networks committee.append(net_dict) valid_accuracy.append(results['best_accuracy']) w_tot = param_vector(net_dict, regression=True) # add weights to accumulator accum_w[ifold*nfilter:(ifold+1)*nfilter] = w_tot save_path = os.path.join(OUTDIR, 'network_committee.pkl') with open(save_path, 'wb') as f: pickle.dump((committee, valid_accuracy), f, -1) ''' committee, valid_accuracy = pickle.load(open(save_path, 'r')) # retrieve the filter weights for ifold, net_dict in enumerate(committee): w_tot = param_vector(net_dict, regression=True) # add weights to accumulator accum_w[ifold*nfilter:(ifold+1)*nfilter] = w_tot ''' # choose the strong signatures (all of them) w_strong = accum_w # members of each cluster should have cosine similarity > 0.7 # equivalently, cosine distance < 0.3 Z = linkage(w_strong, 'average', metric='cosine') clusters = fcluster(Z, .3, criterion='distance') - 1 n_clusters = len(np.unique(clusters)) print '%d clusters chosen' % (n_clusters) # plot the discovered filter profiles plt.figure(figsize=(3,2)) idx = range(nmark) + [nmark+1] clmap = sns.clustermap(pd.DataFrame(w_strong[:,idx], columns=labels+['survival']), method='average', metric='cosine', row_linkage=Z, col_cluster=False, robust=True, yticklabels=clusters) clmap.cax.set_visible(False) fig_path = os.path.join(OUTDIR, 'HIV_clmap.eps') clmap.savefig(fig_path, format='eps') plt.close() # generate the consensus filter profiles c = Counter(clusters) cons = [] for key, val in c.items(): if val > nfold/2: cons.append(np.mean(w_strong[clusters == key], axis=0)) cons_mat = np.vstack(cons) # plot the consensus filter profiles plt.figure(figsize=(10, 3)) idx = range(nmark) + [nmark+1] ax = sns.heatmap(pd.DataFrame(cons_mat[:,idx], columns=labels + ['survival']), robust=True, yticklabels=False) plt.xticks(rotation=90) ax.tick_params(axis='both', which='major', labelsize=20) plt.tight_layout() fig_path = os.path.join(OUTDIR, 'clmap_consensus.eps') plt.savefig(fig_path, format='eps') plt.close() # create an ensemble of neural networks ncell_cons = 3000 ncell_voter = 3000 layers_voter = [ (layers.InputLayer, {'name': 'input', 'shape': (None, nmark, ncell_voter)}), (layers.Conv1DLayer, {'name': 'conv', 'num_filters': nfilter, 'filter_size': 1}), (layers.Pool1DLayer, {'name': 'meanPool', 'pool_size' : ncell_voter, 'mode': 'average_exc_pad'}), (layers.DenseLayer, {'name': 'output', 'num_units': 1, 'nonlinearity': T.tanh})] # predict on the test cohort small_data_list_v = [x[:ncell_cons].T.reshape(1,nmark,ncell_cons) for x in validation_list] data_v = np.vstack(small_data_list_v) stime, censor = y_valid[:,0], y_valid[:,1] # committee of the best nfold/2 models voter_risk_pred = list() for ifold in np.argsort(valid_accuracy): voter = NeuralNet(layers = layers_voter, update = nesterov_momentum, update_learning_rate = 0.001, regression=True, max_epochs=5, verbose=0) voter.load_params_from(committee[ifold]) voter.initialize() # rank the risk predictions voter_risk_pred.append(ss.rankdata(- np.squeeze(voter.predict(data_v)))) all_voters = np.vstack(voter_risk_pred) # compute mean rank per individual risk_p = np.mean(all_voters, axis=0) g1 = np.squeeze(risk_p > np.median(risk_p)) voters_pval_v = logrank_pval(stime, censor, g1) fig_v = os.path.join(OUTDIR, 'cellCnn_cox_test.eps') plot_KM(stime, censor, g1, voters_pval_v, fig_v) # filter-activating cells data_t = np.vstack(small_data_list_v) data_stack = np.vstack([x for x in np.swapaxes(data_t, 2, 1)]) # finally define a network from the consensus filters nfilter_cons = cons_mat.shape[0] ncell_cons = 3000 layers_cons = [ (layers.InputLayer, {'name': 'input', 'shape': (None, nmark, ncell_cons)}), (layers.Conv1DLayer, {'name': 'conv', 'b': init.Constant(cons_mat[:,-2]), 'W': cons_mat[:,:-2].reshape(nfilter_cons, nmark, 1), 'num_filters': nfilter_cons, 'filter_size': 1}), (layers.Pool1DLayer, {'name': 'meanPool', 'pool_size' : ncell_cons, 'mode': 'average_exc_pad'}), (layers.DenseLayer, {'name': 'output', 'num_units': 1, 'W': np.sign(cons_mat[:,-1:]), 'b': init.Constant(0.), 'nonlinearity': T.tanh})] net_cons = NeuralNet(layers = layers_cons, update = nesterov_momentum, update_learning_rate = 0.001, regression=True, max_epochs=5, verbose=0) net_cons.initialize() # get the representation after mean pooling xs = T.tensor3('xs').astype(theano.config.floatX) act_conv = theano.function([xs], lh.get_output(net_cons.layers_['conv'], xs)) # and apply to the test data act_tot = act_conv(data_t) act_tot = np.swapaxes(act_tot, 2, 1) act_stack = np.vstack([x for x in act_tot]) idx = range(7) + [8,9] for i_map in range(nfilter_cons): val = act_stack[:, i_map] descending_order = np.argsort(val)[::-1] val_cumsum = np.cumsum(val[descending_order]) data_sorted = data_stack[descending_order] thres = 0.75 * val_cumsum[-1] res_data = data_sorted[val_cumsum < thres] fig_path = os.path.join(OUTDIR, 'filter_'+str(i_map)+'_active.eps') plot_marker_distribution([res_data[:,idx], data_stack[:,idx]], ['filter '+str(i_map), 'all'], [labels[l] for l in idx], (3,3), fig_path, 24)
def write(self, message): self.terminal.write(message) self.log.write(message) def flush(self): # this flush method is needed for python 3 compatibility. # this handles the flush command by doing nothing. # you might want to specify some extra behavior here. pass sys.stdout = Logger() # cnn init cnn.load_params_from('./model_trained_on_UCF.pkl') if os.path.exists('./data_cache/combined_dataset/cnn_' + CNNCode + '-' + TrainCode + '.pkl'): # check if a trained model already exists cnn.load_params_from('./data_cache/combined_dataset/cnn_' + CNNCode + '-' + TrainCode + '.pkl') else: cnn_train = time.time() # training a new model for epoch in range(Epochs): # for every epoch for batch in patches_extract_all(Train): # for every batch inputs, targets = batch # data augmentation
objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, batch_iterator_train=train_iterator, batch_iterator_test=test_iterator, on_epoch_finished=[ save_weights, save_training_history, plot_training_history ], verbose=10, max_epochs=250, ) if __name__ == '__main__': # X_train, X_test are image file names # They will be read in the iterator X_train, X_test, y_train, y_test = load_data(test_size=0.25, random_state=42) net.fit(X_train, y_train) # Load the best weights from pickled model net.load_params_from('./examples/cifar10/model_weights.pkl') score = net.score(X_test, y_test) print 'Final score %.4f' % score
def fit_net2(fname='net.pickle', sfname='net2.pickle'): with open(fname, 'r') as f: net = pickle.load(f) l1=net.get_all_layers() net2 = NeuralNet( layers=[ ('input', layers.InputLayer), ('conv1', Conv2DLayer), ('pool1', MaxPool2DLayer), ('dropout1', layers.DropoutLayer), ('conv2', Conv2DLayer), ('pool2', MaxPool2DLayer), ('dropout2', layers.DropoutLayer), ('conv3', Conv2DLayer), ('pool3', MaxPool2DLayer), ('dropout3', layers.DropoutLayer), ('hidden4', FactoredLayer), ('dropout4', layers.DropoutLayer), ('hidden5', FactoredLayer), ('output', layers.DenseLayer), ], input_shape=(None, 1, 96, 96), conv1_num_filters=32, conv1_filter_size=(3, 3), pool1_pool_size=(2, 2), dropout1_p=0.1, conv2_num_filters=64, conv2_filter_size=(2, 2), pool2_pool_size=(2, 2), dropout2_p=0.2, conv3_num_filters=128, conv3_filter_size=(2, 2), pool3_pool_size=(2, 2), dropout3_p=0.3, hidden4_num_units=1000, hidden4_num_hidden=200, hidden4_W=l1[10].W.get_value(), hidden4_b=l1[10].b.get_value(), dropout4_p=0.5, hidden5_num_units=1000, hidden5_num_hidden=200, hidden5_W=l1[12].W.get_value(), hidden5_b=l1[12].b.get_value(), output_num_units=30, output_nonlinearity=None, update_learning_rate=theano.shared(float32(0.03)), update_momentum=theano.shared(float32(0.9)), regression=True, batch_iterator_train=FlipBatchIterator(batch_size=128), on_epoch_finished=[ AdjustVariable('update_learning_rate', start=0.03, stop=0.0001), AdjustVariable('update_momentum', start=0.9, stop=0.999), EarlyStopping(patience=200), ], max_epochs=1, verbose=1, ) X, y = load2d() net2.fit(X, y) net2.load_params_from(net.get_all_params_values()) #net2.fit(X, y) """ l2=net2.get_all_layers() print(l2) for i in xrange(len(l1)): if i!=10 and i!=12: all_param_values = lasagne.layers.get_all_param_values(l1[i]) lasagne.layers.set_all_param_values(l2[i], all_param_values) """ with open(sfname, 'wb') as f: pickle.dump(net2, f, -1)
nn = NeuralNet( net['softmax'], max_epochs=1, update=adam, update_learning_rate=.00014, #start with a really low learning rate #objective_l2=0.0001, # batch iteration params batch_iterator_test=test_iterator, train_split=TrainSplit(eval_size=0.2), verbose=3, ) nn.load_params_from(netfile); nuclei_area = 0.0 mitosis_area = 0.0 num = 0 for img in images: cntr = Controller(img) if normalized: img, _, __, __ = macenko(cntr) plt.imsave('data/imagemap' + str(num) + ".png", img) num += 1
def main(): # Parse command line options parser = argparse.ArgumentParser(description='Test different nets with 3D data.') parser.add_argument('--flair', action='store', dest='flair', default='FLAIR_preprocessed.nii.gz') parser.add_argument('--pd', action='store', dest='pd', default='DP_preprocessed.nii.gz') parser.add_argument('--t2', action='store', dest='t2', default='T2_preprocessed.nii.gz') parser.add_argument('--t1', action='store', dest='t1', default='T1_preprocessed.nii.gz') parser.add_argument('--output', action='store', dest='output', default='output.nii.gz') parser.add_argument('--no-docker', action='store_false', dest='docker', default=True) c = color_codes() patch_size = (15, 15, 15) options = vars(parser.parse_args()) batch_size = 10000 min_size = 30 print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Loading the net ' + c['b'] + '1' + c['nc'] + c['g'] + '>' + c['nc']) net_name = '/usr/local/nets/deep-challenge2016.init.model_weights.pkl' if options['docker'] \ else './deep-challenge2016.init.model_weights.pkl' net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, verbose=10, max_epochs=50, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda p, t: 2 * np.sum(p * t[:, 1]) / np.sum((p + t[:, 1])))], ) net.load_params_from(net_name) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Creating the probability map ' + c['b'] + '1' + c['nc'] + c['g'] + '>' + c['nc']) names = np.array([options['flair'], options['pd'], options['t2'], options['t1']]) image_nii = load_nii(options['flair']) image1 = np.zeros_like(image_nii.get_data()) print('0% of data tested', end='\r') sys.stdout.flush() for batch, centers, percent in load_patch_batch_percent(names, batch_size, patch_size): y_pred = net.predict_proba(batch) print('%f%% of data tested' % percent, end='\r') sys.stdout.flush() [x, y, z] = np.stack(centers, axis=1) image1[x, y, z] = y_pred[:, 1] print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Loading the net ' + c['b'] + '2' + c['nc'] + c['g'] + '>' + c['nc']) net_name = '/usr/local/nets/deep-challenge2016.final.model_weights.pkl' if options['docker'] \ else './deep-challenge2016.final.model_weights.pkl' net = NeuralNet( layers=[ (InputLayer, dict(name='in', shape=(None, 4, 15, 15, 15))), (Conv3DDNNLayer, dict(name='conv1_1', num_filters=32, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_1', pool_size=2, stride=2, mode='average_inc_pad')), (Conv3DDNNLayer, dict(name='conv2_1', num_filters=64, filter_size=(5, 5, 5), pad='same')), (Pool3DDNNLayer, dict(name='avgpool_2', pool_size=2, stride=2, mode='average_inc_pad')), (DropoutLayer, dict(name='l2drop', p=0.5)), (DenseLayer, dict(name='l1', num_units=256)), (DenseLayer, dict(name='out', num_units=2, nonlinearity=nonlinearities.softmax)), ], objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.0001, batch_iterator_train=BatchIterator(batch_size=4096), verbose=10, max_epochs=2000, train_split=TrainSplit(eval_size=0.25), custom_scores=[('dsc', lambda t, p: 2 * np.sum(t * p[:, 1]) / np.sum((t + p[:, 1])))], ) net.load_params_from(net_name) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Creating the probability map ' + c['b'] + '2' + c['nc'] + c['g'] + '>' + c['nc']) image2 = np.zeros_like(image_nii.get_data()) print('0% of data tested', end='\r') sys.stdout.flush() for batch, centers, percent in load_patch_batch_percent(names, batch_size, patch_size): y_pred = net.predict_proba(batch) print('%f%% of data tested' % percent, end='\r') sys.stdout.flush() [x, y, z] = np.stack(centers, axis=1) image2[x, y, z] = y_pred[:, 1] print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<Saving to file ' + c['b'] + options['output'] + c['nc'] + c['g'] + '>' + c['nc']) image = (image1 * image2) > 0.5 # filter candidates < min_size labels, num_labels = ndimage.label(image) lesion_list = np.unique(labels) num_elements_by_lesion = ndimage.labeled_comprehension(image, labels, lesion_list, np.sum, float, 0) filt_min_size = num_elements_by_lesion >= min_size lesion_list = lesion_list[filt_min_size] image = reduce(np.logical_or, map(lambda lab: lab == labels, lesion_list)) image_nii.get_data()[:] = np.roll(np.roll(image, 1, axis=0), 1, axis=1) path = '/'.join(options['t1'].rsplit('/')[:-1]) outputname = options['output'].rsplit('/')[-1] image_nii.to_filename(os.path.join(path, outputname)) if not options['docker']: path = '/'.join(options['output'].rsplit('/')[:-1]) case = options['output'].rsplit('/')[-1] gt = load_nii(os.path.join(path, 'Consensus.nii.gz')).get_data().astype(dtype=np.bool) dsc = np.sum(2.0 * np.logical_and(gt, image)) / (np.sum(gt) + np.sum(image)) print(c['c'] + '[' + strftime("%H:%M:%S") + '] ' + c['g'] + '<DSC value for ' + c['c'] + case + c['g'] + ' = ' + c['b'] + str(dsc) + c['nc'] + c['g'] + '>' + c['nc'])
def cascade_model(options): """ 3D cascade model using Nolearn and Lasagne Inputs: - model_options: - weights_path: path to where weights should be saved Output: - nets = list of NeuralNets (CNN1, CNN2) """ # model options channels = len(options['modalities']) train_split_perc = options['train_split'] num_epochs = options['max_epochs'] max_epochs_patience = options['patience'] # save model to disk to re-use it. Create an experiment folder # organize experiment if not os.path.exists( os.path.join(options['weight_paths'], options['experiment'])): os.mkdir(os.path.join(options['weight_paths'], options['experiment'])) if not os.path.exists( os.path.join(options['weight_paths'], options['experiment'], 'nets')): os.mkdir( os.path.join(options['weight_paths'], options['experiment'], 'nets')) # -------------------------------------------------- # first model # -------------------------------------------------- layer1 = InputLayer(name='in1', shape=(None, channels) + options['patch_size']) layer1 = batch_norm(Conv3DLayer(layer1, name='conv1_1', num_filters=32, filter_size=3, pad='same'), name='BN1') layer1 = Pool3DLayer(layer1, name='avgpool_1', mode='max', pool_size=2, stride=2) layer1 = batch_norm(Conv3DLayer(layer1, name='conv2_1', num_filters=64, filter_size=3, pad='same'), name='BN2') layer1 = Pool3DLayer(layer1, name='avgpoo2_1', mode='max', pool_size=2, stride=2) layer1 = DropoutLayer(layer1, name='l2drop', p=0.5) layer1 = DenseLayer(layer1, name='d_1', num_units=256) layer1 = DenseLayer(layer1, name='out', num_units=2, nonlinearity=nonlinearities.softmax) # save weights net_model = 'model_1' net_weights = os.path.join(options['weight_paths'], options['experiment'], 'nets', net_model + '.pkl') net_history = os.path.join(options['weight_paths'], options['experiment'], 'nets', net_model + '_history.pkl') net1 = NeuralNet( layers=layer1, objective_loss_function=objectives.categorical_crossentropy, batch_iterator_train=Rotate_batch_Iterator(batch_size=128), update=updates.adadelta, on_epoch_finished=[ SaveWeights(net_weights, only_best=True, pickle=False), SaveTrainingHistory(net_history), EarlyStopping(patience=max_epochs_patience) ], verbose=options['net_verbose'], max_epochs=num_epochs, train_split=TrainSplit(eval_size=train_split_perc), ) # -------------------------------------------------- # second model # -------------------------------------------------- layer2 = InputLayer(name='in2', shape=(None, channels) + options['patch_size']) layer2 = batch_norm(Conv3DLayer(layer2, name='conv1_1', num_filters=32, filter_size=3, pad='same'), name='BN1') layer2 = Pool3DLayer(layer2, name='avgpool_1', mode='max', pool_size=2, stride=2) layer2 = batch_norm(Conv3DLayer(layer2, name='conv2_1', num_filters=64, filter_size=3, pad='same'), name='BN2') layer2 = Pool3DLayer(layer2, name='avgpoo2_1', mode='max', pool_size=2, stride=2) layer2 = DropoutLayer(layer2, name='l2drop', p=0.5) layer2 = DenseLayer(layer2, name='d_1', num_units=256) layer2 = DenseLayer(layer2, name='out', num_units=2, nonlinearity=nonlinearities.softmax) # save weights net_model = 'model_2' net_weights2 = os.path.join(options['weight_paths'], options['experiment'], 'nets', net_model + '.pkl') net_history2 = os.path.join(options['weight_paths'], options['experiment'], 'nets', net_model + '_history.pkl') net2 = NeuralNet( layers=layer2, objective_loss_function=objectives.categorical_crossentropy, batch_iterator_train=Rotate_batch_Iterator(batch_size=128), update=updates.adadelta, on_epoch_finished=[ SaveWeights(net_weights2, only_best=True, pickle=False), SaveTrainingHistory(net_history2), EarlyStopping(patience=max_epochs_patience) ], verbose=options['net_verbose'], max_epochs=num_epochs, train_split=TrainSplit(eval_size=train_split_perc), ) # upload weights if set if options['load_weights'] == 'True': print " --> CNN, loading weights from", options[ 'experiment'], 'configuration' net1.load_params_from(net_weights) net2.load_params_from(net_weights2) return [net1, net2]
def create_pretrained_vgg_nn_nolearn(): ''' *** This function need only be run once to create and save a nolearn NeuralNet *** *** instance from the origninal lasagne layer weights for the vgg net. *** Create a vgg neural net. Load pretrained weights. Pickle the entire net. Pickle the mean image. Return a nolearn.NeuralNet instance, mean_image numpy array ''' # define the vgg_s network vgg_nn = NeuralNet( layers = [ (InputLayer, { 'name':'input', 'shape':(None,3,224,224) }), (ConvLayer, { 'name':'conv1', 'num_filters':96, 'filter_size':(7,7), 'stride':2, 'flip_filters':False }), (NormLayer, { 'name':'norm1', 'alpha':.0001 }), (PoolLayer, { 'name':'pool1', 'pool_size':(3,3), 'stride':3, 'ignore_border':False }), (ConvLayer, { 'name':'conv2', 'num_filters':256, 'filter_size':(5,5), 'flip_filters':False # 'pad':2, # 'stride':1 }), (PoolLayer, { 'name':'pool2', 'pool_size':(2,2), 'stride':2, 'ignore_border':False }), (ConvLayer, { 'name':'conv3', 'num_filters':512, 'filter_size':(3,3), 'pad':1, # 'stride':1 'flip_filters':False }), (ConvLayer, { 'name':'conv4', 'num_filters':512, 'filter_size':(3,3), 'pad':1, # 'stride':1 'flip_filters':False }), (ConvLayer, { 'name':'conv5', 'num_filters':512, 'filter_size':(3,3), 'pad':1, # 'stride':1 'flip_filters':False }), (PoolLayer, { 'name':'pool5', 'pool_size':(3,3), 'stride':3, 'ignore_border':False }), (DenseLayer,{ 'name':'fc6', 'num_units':4096 }), (DropoutLayer, { 'name':'drop6', 'p':.5 }), (DenseLayer, { 'name':'fc7', 'num_units':4096 }), ], # # optimization method: update=nesterov_momentum, update_learning_rate=0.01, update_momentum=0.9, # Do not need these unless trainng the net. # regression=True, # flag to indicate we're dealing with regression problem # max_epochs=400, # we want to train this many epochs # verbose=1, ) # upload pretrained weights vgg_nn.initialize() vgg_nn.load_params_from('./vgg_nolearn_saved_wts_biases.pkl') # upload mean image model = pickle.load(open('./vgg_cnn_s.pkl')) mean_image = model['mean image'] # pickel the model and the mean image with open("/data/mean_image.pkl", 'w') as f: pickle.dump(mean_image, f) with open("/data/full_vgg.pkl", 'w') as f: pickle.dump(vgg_nn, f) return vgg_net, mean_image
def create_cae(folder_path, learning_rate, input_width=300, input_height=140, layers_size=[32, 32, 64, 32, 32], update_momentum=0.9, activation=None, last_layer_activation=tanh, filters_type=9, batch_size=32, epochs=25, train_valid_split=0.2, flip_batch=True): if filters_type == 3: filter_1 = (3, 3) filter_2 = (3, 3) filter_3 = (3, 3) filter_4 = (3, 3) filter_5 = (3, 3) filter_6 = (3, 3) elif filters_type == 5: filter_1 = (5, 5) filter_2 = (5, 5) filter_3 = (5, 5) filter_4 = (5, 5) filter_5 = (5, 5) filter_6 = (5, 5) elif filters_type == 7: filter_1 = (7, 7) filter_2 = (7, 7) filter_3 = (5, 5) filter_4 = (7, 7) filter_5 = (7, 7) filter_6 = (5, 5) elif filters_type == 9: filter_1 = (9, 9) filter_2 = (7, 7) filter_3 = (5, 5) filter_4 = (7, 7) filter_5 = (9, 9) filter_6 = (5, 5) cnn = NeuralNet(layers=[ ('input', layers.InputLayer), ('conv1', layers.Conv2DLayer), ('conv11', layers.Conv2DLayer), ('conv12', layers.Conv2DLayer), ('pool1', layers.MaxPool2DLayer), ('conv2', layers.Conv2DLayer), ('conv21', layers.Conv2DLayer), ('conv22', layers.Conv2DLayer), ('pool2', layers.MaxPool2DLayer), ('conv3', layers.Conv2DLayer), ('conv31', layers.Conv2DLayer), ('conv32', layers.Conv2DLayer), ('unpool1', Unpool2DLayer), ('conv4', layers.Conv2DLayer), ('conv41', layers.Conv2DLayer), ('conv42', layers.Conv2DLayer), ('unpool2', Unpool2DLayer), ('conv5', layers.Conv2DLayer), ('conv51', layers.Conv2DLayer), ('conv52', layers.Conv2DLayer), ('conv6', layers.Conv2DLayer), ('output_layer', ReshapeLayer), ], input_shape=(None, 1, input_width, input_height), # Layer current size - 1x300x140 conv1_num_filters=layers_size[0], conv1_filter_size=filter_1, conv1_nonlinearity=activation, conv1_border_mode="same", # conv1_pad="same", conv11_num_filters=layers_size[0], conv11_filter_size=filter_1, conv11_nonlinearity=activation, conv11_border_mode="same", # conv11_pad="same", conv12_num_filters=layers_size[0], conv12_filter_size=filter_1, conv12_nonlinearity=activation, conv12_border_mode="same", # conv12_pad="same", pool1_pool_size=(2, 2), conv2_num_filters=layers_size[1], conv2_filter_size=filter_2, conv2_nonlinearity=activation, conv2_border_mode="same", # conv2_pad="same", conv21_num_filters=layers_size[1], conv21_filter_size=filter_2, conv21_nonlinearity=activation, conv21_border_mode="same", # conv21_pad="same", conv22_num_filters=layers_size[1], conv22_filter_size=filter_2, conv22_nonlinearity=activation, conv22_border_mode="same", # conv22_pad="same", pool2_pool_size=(2, 2), conv3_num_filters=layers_size[2], conv3_filter_size=filter_3, conv3_nonlinearity=activation, conv3_border_mode="same", # conv3_pad="same", conv31_num_filters=layers_size[2], conv31_filter_size=filter_3, conv31_nonlinearity=activation, conv31_border_mode="same", # conv31_pad="same", conv32_num_filters=1, conv32_filter_size=filter_3, conv32_nonlinearity=activation, conv32_border_mode="same", # conv32_pad="same", unpool1_ds=(2, 2), conv4_num_filters=layers_size[3], conv4_filter_size=filter_4, conv4_nonlinearity=activation, conv4_border_mode="same", # conv4_pad="same", conv41_num_filters=layers_size[3], conv41_filter_size=filter_4, conv41_nonlinearity=activation, conv41_border_mode="same", # conv41_pad="same", conv42_num_filters=layers_size[3], conv42_filter_size=filter_4, conv42_nonlinearity=activation, conv42_border_mode="same", # conv42_pad="same", unpool2_ds=(2, 2), conv5_num_filters=layers_size[4], conv5_filter_size=filter_5, conv5_nonlinearity=activation, conv5_border_mode="same", # conv5_pad="same", conv51_num_filters=layers_size[4], conv51_filter_size=filter_5, conv51_nonlinearity=activation, conv51_border_mode="same", # conv51_pad="same", conv52_num_filters=layers_size[4], conv52_filter_size=filter_5, conv52_nonlinearity=activation, conv52_border_mode="same", # conv52_pad="same", conv6_num_filters=1, conv6_filter_size=filter_6, conv6_nonlinearity=last_layer_activation, conv6_border_mode="same", # conv6_pad="same", output_layer_shape=(([0], -1)), update_learning_rate=learning_rate, update_momentum=update_momentum, update=nesterov_momentum, train_split=TrainSplit(eval_size=train_valid_split), batch_iterator_train=FlipBatchIterator(batch_size=batch_size) if flip_batch else BatchIterator( batch_size=batch_size), regression=True, max_epochs=epochs, verbose=1, hiddenLayer_to_output=-11) # try: # pickle.dump(cnn, open(folder_path + 'conv_ae.pkl', 'w')) # # cnn = pickle.load(open(folder_path + 'conv_ae.pkl','r')) # cnn.save_weights_to(folder_path + 'conv_ae.np') # except: # print("Could not pickle cnn") cnn.load_params_from(folder_path + CONV_AE_NP) # cnn.load_weights_from(folder_path + CONV_AE_NP) return cnn
'ignore_border': False }), (DenseLayer, { 'name': 'fc6', 'num_units': 4096 }), (DropoutLayer, { 'name': 'drop6', 'p': 0.5 }), (DenseLayer, { 'name': 'fc7', 'num_units': 4096 }) ] net0 = NeuralNet( layers=layers0, update=nesterov_momentum, update_learning_rate=0.01, update_momentum=0.9, # regression=True, # flag to indicate we're dealing with regression problem # max_epochs=400, # we want to train this many epochs verbose=1, ) net0.load_params_from('nolearn_with_w_b.pkl') with open('cars_net.pkl', 'wb') as f: pickle.dump(net0, f)
def process(fin, fon, iden, version, evalue, prob, minCoverage, pipeline, version_m): fi = fin # first parameter is the input file # fi = opt.path+"/db/argsdb.reads.align.test.tsv"; print("Loading deep learning model ...") deepL = cPickle.load( open(opt.path+"/model/"+version_m+"/metadata"+version+".pkl")) clf = NeuralNet( layers=model(deepL['input_nodes'], deepL['output_nodes']), update=nesterov_momentum, update_learning_rate=0.01, update_momentum=0.9, regression=False, max_epochs=100, verbose=2, ) clf.load_params_from(opt.path+"/model/"+version_m+"/model"+version+".pkl") # print deepL['features'] print("loading gene lengths") glen = {i.split()[0]: float(i.split()[1]) for i in open( opt.path+"/database/"+version_m+"/features.gene.length")} print("Loading sample to analyze") [align, BH] = process_blast.make_alignments_json( fi, iden=iden, eval=evalue, coverage=minCoverage, BitScore=True, Features=deepL['features'], glen=glen, pipeline=pipeline) # print align print("Predicting ARG-like reads: Running deepARG" + version+" model version "+version_m) print("input dataset is splitted into chunks of 10000 reads") chunks_input = chunks(align, size=10000) predict = [] for _chunk in tqdm(chunks_input, total=int(len(align)/10000), unit="chunks"): predict += main(deepL, clf, _chunk, version) # print predict print("Computing relative abundance") fo = open(fon+'.ARG', 'w') # second parameter is the output file fo2 = open(fon+'.potential.ARG', 'w') fo.write("#ARG\tquery-start\tquery-end\tread_id\tpredicted_ARG-class\tbest-hit\tprobability\tidentity\talignment-length\talignment-bitscore\talignment-evalue\tcounts\n") fo2.write("#ARG\tquery-start\tquery-end\tread_id\tpredicted_ARG-class\tbest-hit\tprobability\tidentity\talignment-length\talignment-bitscore\talignment-evalue\tcounts\n") for i in tqdm(predict): # 1 Get the alignments for that sample x_align = align[i[0]] # 2 Get only the alignments with the predicted label x_align = {o: x_align[o] for o in x_align.keys() if "|"+i[1]+"|" in o} # 3 Compute the best Hit if x_align: x_bh = max(x_align.iteritems(), key=operator.itemgetter(1))[0] bs_bh = x_align[x_bh] # print(x_bh, align[i[0]][x_bh]) # print(BH[i[0]]) if i[2] >= prob: fo.write("\t".join([ # gene where read is from (subtype) x_bh.split("|")[-1].upper(), BH[i[0]][2][8], # alignment gene start BH[i[0]][2][9], # alignment gene end i[0], # read-id i[1], # predicted type x_bh, # best hit str(i[2]), # probability BH[i[0]][2][2], # identity BH[i[0]][2][3], # alignment length BH[i[0]][2][-1], # bitscore BH[i[0]][2][-2], # evalue '1' # count ])+"\n" ) else: x_bh = BH[i[0]][0] bs_bh = BH[i[0]][1] fo2.write("\t".join([ # gene where read is from (subtype) x_bh.split("|")[-1].upper(), BH[i[0]][2][8], # alignment gene start BH[i[0]][2][9], # alignment gene end i[0], # read-id i[1], # predicted type x_bh, # best hit str(i[2]), # probability BH[i[0]][2][2], # identity BH[i[0]][2][3], # alignment length BH[i[0]][2][-1], # bitscore BH[i[0]][2][-2], # evalue '1' # count ])+"\n" ) else: x_bh = BH[i[0]][0] bs_bh = BH[i[0]][1] fo2.write("\t".join([ # gene where read is from (subtype) x_bh.split("|")[-1].upper(), BH[i[0]][2][8], # alignment gene start BH[i[0]][2][9], # alignment gene end i[0], # read-id i[1], # predicted type "undefined", # best hit str(i[2]), # probability BH[i[0]][2][2], # identity BH[i[0]][2][3], # alignment length BH[i[0]][2][-1], # bitscore BH[i[0]][2][-2], # evalue # x_bh, # problematic-classification: when the prediction class has a different best feature (the arg cannot be defined - probably because errors in the database ) '1' ])+"\n" ) # remove entries with low coverage # if float(BH[i[0]][2][3])/glen[x_bh] < minlenper: continue fo.close() fo2.close()
class CNN(object): __metaclass__ = Singleton channels = 3 image_size = [64, 64] layers = [ # layer dealing with the input data (InputLayer, { 'shape': (None, channels, image_size[0], image_size[1]) }), # first stage of our convolutional layers (Conv2DLayer, { 'num_filters': 32, 'filter_size': 9 }), (Conv2DLayer, { 'num_filters': 32, 'filter_size': 5 }), (MaxPool2DLayer, { 'pool_size': 2 }), # second stage of our convolutional layers (Conv2DLayer, { 'num_filters': 32, 'filter_size': 5 }), (Conv2DLayer, { 'num_filters': 32, 'filter_size': 3 }), (MaxPool2DLayer, { 'pool_size': 2 }), # two dense layers with dropout (DenseLayer, { 'num_units': 256 }), (DropoutLayer, {}), (DenseLayer, { 'num_units': 256 }), # the output layer (DenseLayer, { 'num_units': 2, 'nonlinearity': softmax }), ] def __init__(self): logger = logging.getLogger(__name__) logger.info("Initializing neural net...") self.net = NeuralNet(layers=self.layers, update_learning_rate=0.0002) self.net.load_params_from("conv_params") logger.info("Finished loading parameters") def resize(self, infile): try: im = Image.open(infile) resized_im = np.array(ImageOps.fit( im, (self.image_size[0], self.image_size[1]), Image.ANTIALIAS), dtype=np.uint8) rgb = np.array([ resized_im[:, :, 0], resized_im[:, :, 1], resized_im[:, :, 2] ]) return rgb.reshape(1, self.channels, self.image_size[0], self.image_size[1]) except IOError: return "cannot create thumbnail for '%s'" % infile def predict(self, X): p**n = self.net.predict(X)[0] == 1 return "true" if p**n else "false"
def main(input_file, model_path): batch_size = 128 nb_classes = 62 # A-Z, a-z and 0-9 nb_epoch = 2 # Input image dimensions img_rows, img_cols = 32, 32 # Path of data files path = input_file ### PREDICTION ### # # Load the model with the highest validation accuracy # model.load_weights("best.kerasModelWeights") # Load Kaggle test set X_test = np.load(path + "/testPreproc_" + str(img_rows) + "_" + str(img_cols) + ".npy") print X_test.shape # Load the preprocessed data and labels X_train_all = np.load(path + "/trainPreproc_" + str(img_rows) + "_" + str(img_cols) + ".npy") Y_train_all = np.load(path + "/labelsPreproc.npy") X_train, X_val, Y_train, Y_val = \ train_test_split(X_train_all, Y_train_all, test_size=0.25, stratify=np.argmax(Y_train_all, axis=1)) print X_train.shape Y_val = convert_(Y_val) X_train = X_train.reshape((-1, 1, 32, 32)) # # # input shape for neural network # labels = labels.astype(np.uint8) X_val = X_val.reshape((-1, 1, 32, 32)) # # # input shape for neural network Y_val = Y_val.astype(np.uint8) # input_image_vector_shape = (None, 1, 32, 32) # ''' @description: Two layer convolutional neural network ''' #input layer input_layer = ('input', layers.InputLayer) # fist layer design first_layer_conv_filter = layers.Conv2DLayer first_layer_pool_filter = layers.MaxPool2DLayer conv_filter = ('conv2d1', first_layer_conv_filter) pool_filter = ('maxpool1', first_layer_pool_filter) # second layer design second_layer_conv_filter = layers.Conv2DLayer second_layer_pool_filter = layers.MaxPool2DLayer conv_filter2 = ('conv2d2', second_layer_conv_filter) pool_filter2 = ('maxpool2', second_layer_pool_filter) # dropout rates ( used for regularization ) dropout_layer = layers.DropoutLayer drop1 = 0.5 drop2 = 0.5 first_drop_layer = ('dropout1', dropout_layer) second_drop_layer = ('dropout2', dropout_layer) # # network parameters design_layers = [ input_layer, conv_filter, pool_filter, conv_filter2, pool_filter2, first_drop_layer, ('dense', layers.DenseLayer), second_drop_layer, ('output', layers.DenseLayer) ] # Neural net object instance net1 = NeuralNet( # declare convolutional neural network layers # convolutional mapping and pooling window sized will be declared # and set to various sizes layers=design_layers, # input layer # vector size of image will be taken as 28 x 28 input_shape=input_image_vector_shape, # first layer convolutional filter # mapping layer set at 5 x 5 conv2d1_num_filters=32, conv2d1_filter_size=(5, 5), conv2d1_nonlinearity=lasagne.nonlinearities.rectify, conv2d1_W=lasagne.init.HeNormal(gain='relu'), # first layer convolutional pool filter # mapping layer set at 2 x 2 maxpool1_pool_size=(2, 2), # second layer convolutional filter # mapping layer set at 5 x 5 conv2d2_num_filters=32, conv2d2_filter_size=(5, 5), conv2d2_nonlinearity=lasagne.nonlinearities.rectify, # second layer convolutional pool filter # mapping layer set at 2 x 2 maxpool2_pool_size=(2, 2), dropout1_p=drop1, # hidden unit density dense_num_units=512, dense_nonlinearity=lasagne.nonlinearities.rectify, # dropout2 dropout2_p=drop2, # output output_nonlinearity=lasagne.nonlinearities.softmax, #corresponds to the amount of target labels to compare to output_num_units=62, # optimization method params # NOTE: Different momentum steepest gradient methods yield varied # results. update=nesterov_momentum, # 69 update_learning_rate=0.01, update_momentum=0.078, # update_learning_rate=1e-4, # update_momentum=0.9, # max_epochs=1000, # update_learning_rate=0.1, # update_momentum=0.003, max_epochs=1000, verbose=1, ) print "Loading Neural Net Parameters..." net1.initialize_layers() net1.load_weights_from('{}_weightfile.w'.format(model_path)) ''' new_twoLayer_paramfile.w new_twoLayer_weightfile.w ''' net1.load_params_from('{}_paramfile.w'.format(model_path)) from sklearn.metrics import classification_report, accuracy_score, confusion_matrix print 'Testing...' y_true, y_pred = Y_val, net1.predict(X_val) # Get our predictions print(classification_report(y_true, y_pred)) # Classification on each digit print net1.predict(X_val) print Y_val a = confusion_matrix(Y_val, net1.predict(X_val)) b = np.trace(a) print 'Training Accuracy: ' + str(float(b) / float(np.sum(a)))
class EmotionClassifier: def __init__(self, data_directory="/home/nicholai/Documents/Emotion Files/", face_data="../FaceData/landmarks.dat", show_image=False, epochs=10, dropout_1=0.5, dropout_2=0.5): self.data_dir = data_directory self.picture_dir = self.data_dir + "cohn-kanade-images/" self.FACS_dir = self.data_dir + "FACS/" self.Emotion_dir = self.data_dir + "Emotion/" self.detector = dlib.get_frontal_face_detector() self.predictor = dlib.shape_predictor(face_data) self.face_sz = 200 self.extra_face_space = 0 self.face_sz += self.extra_face_space self.width = self.face_sz self.height = self.face_sz self.show_img = show_image self.network = NeuralNet( layers=[ ('input', layers.InputLayer), ('conv2d1', layers.Conv2DLayer), # ('conv2d2', layers.Conv2DLayer), ('maxpool1', layers.MaxPool2DLayer), # ('conv2d3', layers.Conv2DLayer), ('conv2d4', layers.Conv2DLayer), ('maxpool2', layers.MaxPool2DLayer), ('dropout1', layers.DropoutLayer), ('learningLayer', layers.DenseLayer), ('learningLayer1', layers.DenseLayer), ('output', layers.DenseLayer), ], # input layer input_shape=(None, 1, self.face_sz, self.face_sz), # layer conv2d1 conv2d1_num_filters=32, conv2d1_filter_size=(5, 5), conv2d1_nonlinearity=lasagne.nonlinearities.rectify, conv2d1_W=lasagne.init.GlorotUniform(), # layer conv2d2 # conv2d2_num_filters=32, # conv2d2_filter_size=(5, 5), # conv2d2_nonlinearity=lasagne.nonlinearities.rectify, # conv2d2_W=lasagne.init.GlorotUniform(), # layer maxpool1 maxpool1_pool_size=(5, 5), # layer conv2d3 # conv2d3_num_filters=32, # conv2d3_filter_size=(5, 5), # conv2d3_nonlinearity=lasagne.nonlinearities.rectify, # conv2d3_W=lasagne.init.GlorotUniform(), # layer conv2d4 conv2d4_num_filters=32, conv2d4_filter_size=(5, 5), conv2d4_nonlinearity=lasagne.nonlinearities.rectify, conv2d4_W=lasagne.init.GlorotUniform(), # layer maxpool2 maxpool2_pool_size=(5, 5), # dropout1a dropout1_p=dropout_1, # dense learningLayer_num_units=1024, learningLayer_nonlinearity=lasagne.nonlinearities.rectify, learningLayer1_num_units=512, learningLayer1_nonlinearity=lasagne.nonlinearities.rectify, # # dropout2 # # dropout2_p=dropout_2, # # dense1 # dense1_num_units=256, # dense1_nonlinearity=lasagne.nonlinearities.rectify, # output output_nonlinearity=lasagne.nonlinearities.softmax, output_num_units=8, # optimization method params regression=False, update=nesterov_momentum, update_learning_rate=theano.shared(np.cast['float32'](0.05)), update_momentum=theano.shared(np.cast['float32'](0.9)), on_epoch_finished=[ AdjustVariable('update_learning_rate', start=0.05, stop=0.01), AdjustVariable('update_momentum', start=0.9, stop=0.999), ], max_epochs=epochs, verbose=2, ) if self.show_img: self.win = dlib.image_window() def load_training_set(self): """ Loads the CK+ data-set of images, processes the facial key-points of each face, and returns the emotion codes of each participant 0-7 (i.e. 0=neutral, 1=anger, 2=contempt, 3=disgust, 4=fear, 5=happy, 6=sadness, 7=surprise) :return: Training X (X_Train) and Y (y_train) Data as well as testing X (X_test) and Y (y_test) Data """ x_train = np.zeros((382, self.width, self.height), dtype='float32') y_train = np.zeros(382, dtype='int32') i = 0 for root, name, files in os.walk(self.picture_dir): files = [file for file in files if file.endswith(".png")] if len(files) == 0: continue fs = sorted(files, key=lambda x: x[:-4]) emotion = self.get_emotion(fs[-1]) # sampleImg = self.get_face_image(os.path.join(root, fs[0])) # print(sampleImg.shape) if emotion != -1: if i % 7 == 0: # self.show_faces(os.path.join(root, fs[0])) # self.show_faces(os.path.join(root, fs[-1])) x_train[i] = self.get_face_image(os.path.join( root, fs[0])) # add the key-points of a neutral face y_train[i] = 0 # emotion code of a neutral face i += 1 x_train[i] = self.get_face_image(os.path.join(root, fs[-1])) y_train[i] = emotion i += 1 print(i) return x_train.astype(np.float32).reshape(-1, 1, self.face_sz, self.face_sz), y_train def load_keypoint_training_set(self): x_train = np.zeros((655, 2, 68), dtype='int16') y_train = np.zeros(655, dtype='int16') i = 0 for root, name, files in os.walk(self.picture_dir): files = [file for file in files if file.endswith(".png")] if len(files) == 0: continue fs = sorted(files, key=lambda x: x[:-4]) emotion = self.get_emotion(fs[-1]) # sampleImg = self.get_face_image(os.path.join(root, fs[0])) # print(sampleImg.shape) if emotion != -1: x_train[i] = self.get_keypoints(os.path.join( root, fs[0])) # add the key-points of a neutral face y_train[i] = 0 # emotion code of a neutral face i += 1 x_train[i] = self.get_keypoints(os.path.join( root, fs[-1])) # add the key-points of an expressed face y_train[i] = emotion i += 1 print(i) return x_train.astype(np.float32).reshape(-1, 1, 2, 68), y_train def get_keypoints(self, image_file): """ Returns the key-point data from the facial recognition process :param image_file: a full file path to an image containing a face :return: a landmarks list """ img = imageio.imread(image_file) details = self.detector(img, 1) landmarks = np.zeros((2, 68), dtype='int16') if self.show_img: self.win.set_image(img) for i, j in enumerate(details): shape = self.predictor(img, j) if self.show_img: self.win.add_overlay(shape) for k in range(0, 68): part = shape.part(k) landmarks[0][k] = part.x landmarks[1][k] = part.y if self.show_img: self.win.add_overlay(details) return landmarks def get_face_image(self, filename): img = imageio.imread(filename) details = self.detector(img, 1) for i, j in enumerate(details): shape = self.predictor(img, j) for k in range(0, 68): part = shape.part(k) img[part.y][part.x] = 255 img = resize(img[j.top():j.bottom(), j.left():j.right()], output_shape=(self.face_sz, self.face_sz), preserve_range=True) if len(img.shape) == 3: img = rgb2gray(img) img = np.asarray(img, dtype='float32') / 255 return img def show_faces(self, filename): img = imageio.imread(filename) details = self.detector(img, 1) for i, j in enumerate(details): shape = self.predictor(img, j) for k in range(0, 68): part = shape.part(k) img[part.y][part.x] = 255 if self.show_img: self.win.set_image(img[j.top():j.bottom(), j.left():j.right()]) def get_full_image(self, filename): img = imageio.imread(filename, True) img = np.asarray(img, dtype='float32') / 255 return img[0:self.width, 0:self.height] def get_facs(self, filename): """ Basically Take a filename that is formatted like so 'S114_005_00000022.png' and turn that into a directory structure which contains a FACS text file named 'S114_005_00000022.txt' in ./FACS/S114/005/ :param filename: Should be the name of the file (only) of the CK+ test picture :return: Returns the FACS codes and Emotion code as FACS, Emotion """ fn = filename[:-4].split("_") # Strip filename filepath = os.path.join(self.FACS_dir, fn[0], fn[1], filename[:-4] + "_emotion.txt") # Craft the File path of the FACS emotion associated with the emotion changes lines = [line.split('\n') for line in open(filepath)] # Read the FACS codes from file return lines def get_emotion(self, filename): fn = filename[:-4].split("_") filepath = os.path.join(self.Emotion_dir, fn[0], fn[1], filename[:-4] + "_emotion.txt") # Craft the File path of the FACS emotion associated with the emotion changes if os.path.isfile(filepath): line = [ int(float(lines.strip(' ').strip('\n'))) for lines in open(filepath) ] return line[0] return -1 def train(self, x_train, y_train, epoch=0): """ Fits training data to the Convolutional Neural Network :param epoch: number of epochs :param x_train: Training x values :param y_train: Training y values """ if epoch == 0: self.network.fit(x_train, y_train) else: self.network.fit(x_train, y_train, epoch) def predict(self, image): return self.network.predict(image) def save_network_state(self, paramsname="params.npz"): self.network.save_params_to(paramsname) def load_network_state(self, paramsname="params.npz"): self.network.load_params_from(paramsname)
def rodar(self): np.set_printoptions(threshold=np.nan) sourcepath = Classificar.sourcepath numerodeimagens = Classificar.numerodeimagens X_test = np.zeros((numerodeimagens, 19200), dtype=np.int) # Allocates space for each new image you want to classify, each line is an image for i in range(1, numerodeimagens): # read the images X_test[i - 1] = np.asarray(Image.open(sourcepath+"galaxy" + str(i) + ".jpg")).reshape( -1)[0:19200] # Reshape the images to help the CNN execution X_test = X_test.reshape((-1, 3, 80, 80)) # Define the CNN, must be the same CNN that is saved into your model that you generated running CNN.py net1 = NeuralNet( layers=[('input', layers.InputLayer), ('conv2d1', layers.Conv2DLayer), ('maxpool1', layers.MaxPool2DLayer), ('conv2d2', layers.Conv2DLayer), ('maxpool2', layers.MaxPool2DLayer), ('conv2d3', layers.Conv2DLayer), ('maxpool3', layers.MaxPool2DLayer), # ('conv2d4', layers.Conv2DLayer), # ('maxpool4', layers.MaxPool2DLayer), ('dropout1', layers.DropoutLayer), # s('dropout2', layers.DropoutLayer), ('dense', layers.DenseLayer), # ('dense2', layers.DenseLayer), ('output', layers.DenseLayer), ], input_shape=(None, 3, 80, 80), conv2d1_num_filters=16, conv2d1_filter_size=(3, 3), conv2d1_nonlinearity=lasagne.nonlinearities.rectify, conv2d1_W=lasagne.init.GlorotUniform(), maxpool1_pool_size=(2, 2), conv2d2_num_filters=16, conv2d2_filter_size=(3, 3), conv2d2_nonlinearity=lasagne.nonlinearities.rectify, maxpool2_pool_size=(2, 2), conv2d3_num_filters=16, conv2d3_filter_size=(3, 3), conv2d3_nonlinearity=lasagne.nonlinearities.rectify, maxpool3_pool_size=(2, 2), # conv2d4_num_filters = 16, # conv2d4_filter_size = (2,2), # conv2d4_nonlinearity = lasagne.nonlinearities.rectify, # maxpool4_pool_size = (2,2), dropout1_p=0.5, # dropout2_p = 0.5, dense_num_units=16, dense_nonlinearity=lasagne.nonlinearities.rectify, # dense2_num_units = 16, # dense2_nonlinearity = lasagne.nonlinearities.rectify, output_nonlinearity=lasagne.nonlinearities.softmax, output_num_units=2, update=nesterov_momentum, update_learning_rate=0.001, update_momentum=0.9, max_epochs=1000, verbose=1, ) net1.load_params_from("/Users/Pedro/PycharmProjects/BIDHU/docs/train.txt") # Read model preds = net1.predict(X_test) # make predictions strpreds = str(preds) strpreds = strpreds.replace(" ", "\n") strpreds = strpreds.replace("1", "yes") strpreds = strpreds.replace("0", "no") xstrpreds = (strpreds.splitlines()) for i in range(len(xstrpreds)): xstrpreds[i] = str(i + 1) + "-" + xstrpreds[i] strpreds = str(xstrpreds) strpreds = strpreds.replace(" ", "\n") strpreds = strpreds.replace("[", "") strpreds = strpreds.replace("]", "") strpreds = strpreds.replace("'", "") strpreds = strpreds.replace(",", "") strpreds = strpreds.replace("-", " - ") return strpreds
(DenseLayer, dict(name='out', num_units=n_classes, nonlinearity=nonlinearities.softmax)), ], regression=False, objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, batch_iterator_train=train_iterator, batch_iterator_test=test_iterator, on_epoch_finished=[ save_weights, save_training_history, plot_training_history ], verbose=10, max_epochs=250, ) if __name__ == '__main__': # X_train, X_test are image file names # They will be read in the iterator X_train, X_test, y_train, y_test = load_data(test_size=0.25, random_state=42) net.fit(X_train, y_train) # Load the best weights from pickled model net.load_params_from('./examples/cifar10/model_weights.pkl') score = net.score(X_test, y_test) print 'Final score %.4f' % score
def build_model(weights_path, options): """ Build the CNN model. Create the Neural Net object and return it back. Inputs: - subject name: used to save the net weights accordingly. - options: several hyper-parameters used to configure the net. Output: - net: a NeuralNet object """ net_model_name = options['experiment'] try: os.mkdir(os.path.join(weights_path, net_model_name)) except: pass net_weights = os.path.join(weights_path, net_model_name, net_model_name + '.pkl') net_history = os.path.join(weights_path, net_model_name, net_model_name + '_history.pkl') # select hyper-parameters t_verbose = options['net_verbose'] train_split_perc = options['train_split'] num_epochs = options['max_epochs'] max_epochs_patience = options['patience'] early_stopping = EarlyStopping(patience=max_epochs_patience) save_weights = SaveWeights(net_weights, only_best=True, pickle=False) save_training_history = SaveTrainingHistory(net_history) # build the architecture ps = options['patch_size'][0] num_channels = 1 fc_conv = 180 fc_fc = 180 dropout_conv = 0.5 dropout_fc = 0.5 # -------------------------------------------------- # channel_1: axial # -------------------------------------------------- axial_ch = InputLayer(name='in1', shape=(None, num_channels, ps, ps)) axial_ch = prelu(batch_norm( Conv2DLayer(axial_ch, name='axial_ch_conv1', num_filters=20, filter_size=3)), name='axial_ch_prelu1') axial_ch = prelu(batch_norm( Conv2DLayer(axial_ch, name='axial_ch_conv2', num_filters=20, filter_size=3)), name='axial_ch_prelu2') axial_ch = MaxPool2DLayer(axial_ch, name='axial_max_pool_1', pool_size=2) axial_ch = prelu(batch_norm( Conv2DLayer(axial_ch, name='axial_ch_conv3', num_filters=40, filter_size=3)), name='axial_ch_prelu3') axial_ch = prelu(batch_norm( Conv2DLayer(axial_ch, name='axial_ch_conv4', num_filters=40, filter_size=3)), name='axial_ch_prelu4') axial_ch = MaxPool2DLayer(axial_ch, name='axial_max_pool_2', pool_size=2) axial_ch = prelu(batch_norm( Conv2DLayer(axial_ch, name='axial_ch_conv5', num_filters=60, filter_size=3)), name='axial_ch_prelu5') axial_ch = DropoutLayer(axial_ch, name='axial_l1drop', p=dropout_conv) axial_ch = DenseLayer(axial_ch, name='axial_d1', num_units=fc_conv) axial_ch = prelu(axial_ch, name='axial_prelu_d1') # -------------------------------------------------- # channel_1: coronal # -------------------------------------------------- coronal_ch = InputLayer(name='in2', shape=(None, num_channels, ps, ps)) coronal_ch = prelu(batch_norm( Conv2DLayer(coronal_ch, name='coronal_ch_conv1', num_filters=20, filter_size=3)), name='coronal_ch_prelu1') coronal_ch = prelu(batch_norm( Conv2DLayer(coronal_ch, name='coronal_ch_conv2', num_filters=20, filter_size=3)), name='coronal_ch_prelu2') coronal_ch = MaxPool2DLayer(coronal_ch, name='coronal_max_pool_1', pool_size=2) coronal_ch = prelu(batch_norm( Conv2DLayer(coronal_ch, name='coronal_ch_conv3', num_filters=40, filter_size=3)), name='coronal_ch_prelu3') coronal_ch = prelu(batch_norm( Conv2DLayer(coronal_ch, name='coronal_ch_conv4', num_filters=40, filter_size=3)), name='coronal_ch_prelu4') coronal_ch = MaxPool2DLayer(coronal_ch, name='coronal_max_pool_2', pool_size=2) coronal_ch = prelu(batch_norm( Conv2DLayer(coronal_ch, name='coronal_ch_conv5', num_filters=60, filter_size=3)), name='coronal_ch_prelu5') coronal_ch = DropoutLayer(coronal_ch, name='coronal_l1drop', p=dropout_conv) coronal_ch = DenseLayer(coronal_ch, name='coronal_d1', num_units=fc_conv) coronal_ch = prelu(coronal_ch, name='coronal_prelu_d1') # -------------------------------------------------- # channel_1: saggital # -------------------------------------------------- saggital_ch = InputLayer(name='in3', shape=(None, num_channels, ps, ps)) saggital_ch = prelu(batch_norm( Conv2DLayer(saggital_ch, name='saggital_ch_conv1', num_filters=20, filter_size=3)), name='saggital_ch_prelu1') saggital_ch = prelu(batch_norm( Conv2DLayer(saggital_ch, name='saggital_ch_conv2', num_filters=20, filter_size=3)), name='saggital_ch_prelu2') saggital_ch = MaxPool2DLayer(saggital_ch, name='saggital_max_pool_1', pool_size=2) saggital_ch = prelu(batch_norm( Conv2DLayer(saggital_ch, name='saggital_ch_conv3', num_filters=40, filter_size=3)), name='saggital_ch_prelu3') saggital_ch = prelu(batch_norm( Conv2DLayer(saggital_ch, name='saggital_ch_conv4', num_filters=40, filter_size=3)), name='saggital_ch_prelu4') saggital_ch = MaxPool2DLayer(saggital_ch, name='saggital_max_pool_2', pool_size=2) saggital_ch = prelu(batch_norm( Conv2DLayer(saggital_ch, name='saggital_ch_conv5', num_filters=60, filter_size=3)), name='saggital_ch_prelu5') saggital_ch = DropoutLayer(saggital_ch, name='saggital_l1drop', p=dropout_conv) saggital_ch = DenseLayer(saggital_ch, name='saggital_d1', num_units=fc_conv) saggital_ch = prelu(saggital_ch, name='saggital_prelu_d1') # FC layer 540 layer = ConcatLayer(name='elem_channels', incomings=[axial_ch, coronal_ch, saggital_ch]) layer = DropoutLayer(layer, name='f1_drop', p=dropout_fc) layer = DenseLayer(layer, name='FC1', num_units=540) layer = prelu(layer, name='prelu_f1') # concatenate channels 540 + 15 layer = DropoutLayer(layer, name='f2_drop', p=dropout_fc) atlas_layer = DropoutLayer(InputLayer(name='in4', shape=(None, 15)), name='Dropout_atlas', p=.2) atlas_layer = InputLayer(name='in4', shape=(None, 15)) layer = ConcatLayer(name='elem_channels2', incomings=[layer, atlas_layer]) # FC layer 270 layer = DenseLayer(layer, name='fc_2', num_units=270) layer = prelu(layer, name='prelu_f2') # FC output 15 (softmax) net_layer = DenseLayer(layer, name='out_layer', num_units=15, nonlinearity=softmax) net = NeuralNet( layers=net_layer, objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=0.001, on_epoch_finished=[ save_weights, save_training_history, early_stopping, ], verbose=t_verbose, max_epochs=num_epochs, train_split=TrainSplit(eval_size=train_split_perc), ) if options['load_weights'] == 'True': try: print " --> loading weights from ", net_weights net.load_params_from(net_weights) except: pass return net
def main(input_file, model_path): batch_size = 128 nb_classes = 62 # A-Z, a-z and 0-9 nb_epoch = 2 # Input image dimensions img_rows, img_cols = 32, 32 # Path of data files path = input_file ### PREDICTION ### # Load the model with the highest validation accuracy # model.load_weights("best.kerasModelWeights") # Load Kaggle test set X_test = np.load(path + "/testPreproc_" + str(img_rows) + "_" + str(img_cols) + ".npy") print X_test.shape # Load the preprocessed data and labels X_train_all = np.load(path + "/trainPreproc_" + str(img_rows) + "_" + str(img_cols) + ".npy") Y_train_all = np.load(path + "/labelsPreproc.npy") X_train, X_val, Y_train, Y_val = \ train_test_split(X_train_all, Y_train_all, test_size=0.25, stratify=np.argmax(Y_train_all, axis=1)) print X_train.shape Y_val = convert_(Y_val) X_train = X_train.reshape((-1, 1, 32, 32)) # # # input shape for neural network # labels = labels.astype(np.uint8) X_val = X_val.reshape((-1, 1, 32, 32)) # # # input shape for neural network Y_val = Y_val.astype(np.uint8) # input_image_vector_shape = (None, 1, 32, 32) net1 = NeuralNet( layers=[ ('input', layers.InputLayer), ('conv2d1', layers.Conv2DLayer), ('maxpool1', layers.MaxPool2DLayer), ('conv2d2', layers.Conv2DLayer), ('maxpool2', layers.MaxPool2DLayer), ('conv2d3', layers.Conv2DLayer), ('maxpool3', layers.MaxPool2DLayer), # ('conv2d4', layers.Conv2DLayer), # ('maxpool4', layers.MaxPool2DLayer), ('dropout1', layers.DropoutLayer), ('dropout2', layers.DropoutLayer), ('dense', layers.DenseLayer), # ('dense2', layers.DenseLayer), ('output', layers.DenseLayer), ], input_shape=input_image_vector_shape, conv2d1_num_filters=128, conv2d1_filter_size=(3, 3), conv2d1_nonlinearity=lasagne.nonlinearities.tanh, conv2d1_W=lasagne.init.GlorotUniform(), conv2d1_pad=(2, 2), maxpool1_pool_size=(2, 2), conv2d2_num_filters=256, conv2d2_filter_size=(3, 3), conv2d2_nonlinearity=lasagne.nonlinearities.rectify, conv2d2_pad=(2, 2), maxpool2_pool_size=(2, 2), conv2d3_num_filters=512, conv2d3_filter_size=(3, 3), conv2d3_nonlinearity=lasagne.nonlinearities.rectify, conv2d3_pad=(2, 2), maxpool3_pool_size=(2, 2), dropout1_p=0.5, dropout2_p=0.5, dense_num_units=8192, dense_nonlinearity=lasagne.nonlinearities.rectify, # dense2_num_units = 16, # dense2_nonlinearity = lasagne.nonlinearities.rectify, output_nonlinearity=lasagne.nonlinearities.softmax, output_num_units=62, update=momentum, # 75.5 with tanh init dense num = 256% update_learning_rate=0.03, update_momentum=0.8, max_epochs=1000, verbose=1, ) print "Loading Neural Net Parameters..." net1.initialize_layers() net1.load_weights_from('{}_weightfile.w'.format(model_path)) net1.load_params_from('{}_paramfile.w'.format(model_path)) from sklearn.metrics import classification_report, accuracy_score, confusion_matrix print 'Testing...' y_true, y_pred = Y_val, net1.predict(X_val) # Get our predictions print(classification_report(y_true, y_pred)) # Classification on each digit print net1.predict(X_val) print Y_val a = confusion_matrix(Y_val, net1.predict(X_val)) b = np.trace(a) print 'Training Accuracy: ' + str(float(b) / float(np.sum(a)))
total_test_time_points = len(X_test) // NO_TIME_POINTS remainder_test_points = len(X_test) % NO_TIME_POINTS no_rows = total_test_time_points * NO_TIME_POINTS X_test = X_test[0:no_rows, :] X_test = X_test.transpose() X_test_Samples = np.split(X_test, total_test_time_points, axis=1) X_test = np.asarray(X_test_Samples) ########################################################################### #######get predictions and write to files for series 9 and series 10####### print("Testing subject%d...." %(subject)) params = net.get_all_params_values() learned_weights = net.load_params_from(params) probabilities = net.predict_proba(X_test) sub9 = 'subj{0}_series{1}'.format(subject, 9) data_len9 = test_dict[sub9] total_time_points9 = data_len9 // NO_TIME_POINTS remainder_data9 = data_len9 % NO_TIME_POINTS sub10 = 'subj{0}_series{1}'.format(subject, 10) data_len10 = test_dict[sub10] total_time_points10 = data_len10 // NO_TIME_POINTS remainder_data10 = data_len10 % NO_TIME_POINTS total_test_points = total_time_points9+total_time_points10 for i, p in enumerate(probabilities):
(DropoutLayer, dict(name='l7drop', p=0.5)), (DenseLayer, dict(name='l8', num_units=256)), (FeaturePoolLayer, dict(name='l8p', pool_size=2)), (DropoutLayer, dict(name='l8drop', p=0.5)), (DenseLayer, dict(name='out', num_units=10, nonlinearity=nonlinearities.softmax)), ], regression=False, objective_loss_function=objectives.categorical_crossentropy, update=updates.adam, update_learning_rate=1e-3, batch_iterator_train=train_iterator, batch_iterator_test=test_iterator, on_epoch_finished=[ save_weights, save_training_history, plot_training_history, early_stopping ], verbose=10, max_epochs=100) if __name__ == '__main__': X_train, X_test, y_train, y_test = load_data(test_size=0.25, random_state=42) net.fit(X_train, y_train) # Load the best weights from pickled model net.load_params_from('./examples/mnist/model_weights.pkl') score = net.score(X_test, y_test) print 'Final score %.4f' % score
class EmotionClassifier: def __init__(self, face_size=192, epochs=100, learning_rate=theano.shared(np.cast['float32'](0.1))): self.network = NeuralNet( layers=[('input', InputLayer), ('conv1', Conv2DLayer), ('conv2', Conv2DLayer), ('pool1', MaxPool2DLayer), ('conv3', Conv2DLayer), ('conv4', Conv2DLayer), ('pool2', MaxPool2DLayer), ('conv5', Conv2DLayer), ('conv6', Conv2DLayer), ('pool3', MaxPool2DLayer), ('conv7', Conv2DLayer), ('conv8', Conv2DLayer), ('pool4', MaxPool2DLayer), ('hidden1', DenseLayer), ('hidden2', DenseLayer), ('output', DenseLayer)], input_shape=(None, 1, face_size, face_size), conv1_num_filters=32, conv1_filter_size=(3, 3), conv1_nonlinearity=lasagne.nonlinearities.rectify, conv1_W=lasagne.init.GlorotUniform(), conv2_num_filters=32, conv2_filter_size=(3, 3), conv2_nonlinearity=lasagne.nonlinearities.rectify, conv2_W=lasagne.init.GlorotUniform(), pool1_pool_size=(2, 2), conv3_num_filters=32, conv3_filter_size=(3, 3), conv3_nonlinearity=lasagne.nonlinearities.rectify, conv3_W=lasagne.init.GlorotUniform(), conv4_num_filters=32, conv4_filter_size=(3, 3), conv4_nonlinearity=lasagne.nonlinearities.rectify, conv4_W=lasagne.init.GlorotUniform(), pool2_pool_size=(2, 2), conv5_num_filters=64, conv5_filter_size=(3, 3), conv5_nonlinearity=lasagne.nonlinearities.rectify, conv5_W=lasagne.init.GlorotUniform(), conv6_num_filters=32, conv6_filter_size=(3, 3), conv6_nonlinearity=lasagne.nonlinearities.rectify, conv6_W=lasagne.init.GlorotUniform(), pool3_pool_size=(2, 2), conv7_num_filters=32, conv7_filter_size=(3, 3), conv7_nonlinearity=lasagne.nonlinearities.rectify, conv7_W=lasagne.init.GlorotUniform(), conv8_num_filters=32, conv8_filter_size=(3, 3), conv8_nonlinearity=lasagne.nonlinearities.rectify, conv8_W=lasagne.init.GlorotUniform(), pool4_pool_size=(2, 2), hidden1_num_units=4096, hidden1_nonlinearity=lasagne.nonlinearities.rectify, hidden2_num_units=2048, output_nonlinearity=lasagne.nonlinearities.softmax, output_num_units=8, regression=False, update=adadelta, # update_momentum=theano.shared(np.cast['float32'](0.9)), # on_epoch_finished=[ # EarlyStopping(patience=20) # AdjustVariable('update_learning_rate', start=learning_start, stop=learning_end), # AdjustVariable('update_momentum', start=0.9, stop=0.999), # ], # batch_iterator_train=ShufflingBatchIteratorMixin, # batch_iterator_train=BatchIterator(251, shuffle=True), max_epochs=epochs, verbose=2) def train(self, x_train, y_train, epoch=0): """ Fits training data to the Convolutional Neural Network :param epoch: number of epochs :param x_train: Training x values :param y_train: Training y values """ if epoch == 0: self.network.fit(x_train, y_train) else: self.network.fit(x_train, y_train, epoch) def predict(self, image): return self.network.predict(image) def save_network_state(self, paramsname="params.npz"): self.network.save_params_to(paramsname) def load_network_state(self, paramsname="params.npz"): self.network.load_params_from(paramsname)
class graspNet(): def __init__(self, param_file=None): net_divider = 1.0 self.layers = [ (L.layers.InputLayer, { 'shape': (None, 7, X_H, X_W), 'name': 'input' }), (L.layers.Conv2DLayer, { 'num_filters': 96, 'stride': 1, 'pad': 3, 'filter_size': (7, 7), 'nonlinearity': L.nonlinearities.rectify, 'flip_filters': False, 'name': 'conv0' }), (L.layers.DropoutLayer, { 'p': 0.0 }), (L.layers.MaxPool2DLayer, { 'pool_size': 3, 'ignore_border': False }), (L.layers.Conv2DLayer, { 'num_filters': 256, 'stride': 1, 'filter_size': (5, 5), 'nonlinearity': L.nonlinearities.rectify, 'flip_filters': False, 'name': 'conv1' }), (L.layers.DropoutLayer, { 'p': 0.0 }), (L.layers.MaxPool2DLayer, { 'pool_size': 2, 'ignore_border': False }), (L.layers.Conv2DLayer, { 'num_filters': 512, 'stride': 1, 'pad': 1, 'filter_size': (3, 3), 'nonlinearity': L.nonlinearities.rectify, 'flip_filters': False, 'name': 'conv2' }), (L.layers.DropoutLayer, { 'p': 0.0 }), (L.layers.Conv2DLayer, { 'num_filters': 512, 'stride': 1, 'pad': 1, 'filter_size': (3, 3), 'nonlinearity': L.nonlinearities.rectify, 'flip_filters': False, 'name': 'conv3' }), (L.layers.DropoutLayer, { 'p': 0.0 }), (L.layers.Conv2DLayer, { 'num_filters': 512, 'stride': 1, 'pad': 1, 'filter_size': (3, 3), 'nonlinearity': L.nonlinearities.rectify, 'flip_filters': False, 'name': 'conv4' }), (L.layers.DropoutLayer, { 'p': 0.0 }), (L.layers.MaxPool2DLayer, { 'pool_size': 3, 'ignore_border': False }), (L.layers.DenseLayer, { 'num_units': 4096, 'nonlinearity': L.nonlinearities.sigmoid, 'name': 'dense0' }), (L.layers.DropoutLayer, { 'p': 0.0 }), (L.layers.DenseLayer, { 'num_units': 4096, 'nonlinearity': L.nonlinearities.sigmoid, 'name': 'dense1' }), (L.layers.DenseLayer, { 'num_units': 1, 'nonlinearity': L.nonlinearities.sigmoid }), ] self.net = NeuralNet( layers=self.layers, update_learning_rate=0.015, update=L.updates.nesterov_momentum, update_momentum=0.9, #update=L.updates.sgd, regression=True, verbose=1, eval_size=0.15, objective_loss_function=L.objectives.binary_crossentropy, max_epochs=200) if param_file != None: print "Loading parameters from ", param_file self.net.load_params_from(param_file) def write_filters_to_file(self, fname): params = self.net.get_all_params() layer_counter = 0 for p in params: print p layer_counter += 1 filter_counter = 0 weights = p.get_value() if len(weights.shape) > 2: for f in weights: kernel = np.asarray(f, dtype=np.float32) kernel = kernel * 255 + 128 viz = np.zeros(shape=kernel[0].shape) viz = cv2.resize(kernel[0], None, fx=20, fy=20, interpolation=cv2.INTER_CUBIC) cv2.normalize(viz, viz) viz = viz * 50 #print viz #cv2.imshow('ha', viz) #cv2.waitKey(-1) viz = viz / 50 viz = viz * 12000 viz = viz #print viz cv2.imwrite( fname + "_" + str(layer_counter) + "_" + str(filter_counter) + ".png", viz) filter_counter += 1 # evaluates the input array over the neural net def eval(self, x): y = np.zeros((x.shape[0], )) for i in range(x.shape[0]): pred = self.net.predict(np.array([x[i]])) y[i] = pred print i, pred return y # train the network in input (x,y) # param_file: input parameter file (perhaps from previous trainings) # out_param_file: output path to write resulting params to # filter_file: output path to write images of filters for visualization # load_params: boolean flag, when set: 1 loads input parameters from <param_file> # pretrain: boolean flag, when set: 1 loads parameters from pretrained network def train(self, X, y, param_file=None, out_param_file=None, filter_file=None, load_params=False, pretrain=False): if pretrain: params = createNoLearnParams(param_file) print "Parameters", params[1].shape conv0_W = np.concatenate((params[0], params[0]), axis=1) conv0_W = np.concatenate((conv0_W, params[0]), axis=1) conv0_W = conv0_W[:, :7, :, :] conv0_b = np.concatenate((params[1], params[1]), axis=0) conv0_b = np.concatenate((conv0_b, params[1]), axis=0) conv0_b = conv0_b[:96] conv1_W = np.concatenate((params[2], params[2]), axis=1) conv1_W = np.concatenate((conv1_W, params[2]), axis=1) conv1_W = conv1_W[:, :96, :, :] conv1_b = np.concatenate((params[3], params[3]), axis=0) conv1_b = np.concatenate((conv1_b, params[3]), axis=0) conv1_b = conv1_b[:256] conv2_W = np.concatenate((params[4], params[4]), axis=1) conv2_W = np.concatenate((conv2_W, params[4]), axis=1) conv2_W = conv2_W[:, :256, :, :] conv2_b = np.concatenate((params[5], params[5]), axis=0) conv2_b = np.concatenate((conv2_b, params[5]), axis=0) conv2_b = conv2_b[:512] conv3_W = np.concatenate((params[6], params[6]), axis=1) conv3_W = np.concatenate((conv3_W, params[6]), axis=1) conv3_W = conv3_W[:, :512, :, :] conv3_b = np.concatenate((params[7], params[7]), axis=0) conv3_b = np.concatenate((conv3_b, params[7]), axis=0) conv3_b = conv3_b[:512] conv4_W = np.concatenate((params[8], params[8]), axis=1) conv4_W = np.concatenate((conv4_W, params[8]), axis=1) conv4_W = conv4_W[:, :512, :, :] conv4_b = np.concatenate((params[9], params[9]), axis=0) conv4_b = np.concatenate((conv4_b, params[9]), axis=0) conv4_b = conv4_b[:512] dense0_W = np.concatenate((params[10], params[10]), axis=1) dense0_W = np.concatenate((dense0_W, params[10]), axis=1) dense0_W = dense0_W[:2560, :4096] dense0_b = np.concatenate((params[11], params[11]), axis=0) dense0_b = np.concatenate((dense0_b, params[11]), axis=0) dense0_b = dense0_b[:4096] dense1_W = np.concatenate((params[12], params[12]), axis=1) dense1_W = np.concatenate((dense1_W, params[12]), axis=1) dense1_W = dense1_W[:4096, :4096] dense1_b = np.concatenate((params[13], params[13]), axis=0) dense1_b = np.concatenate((dense1_b, params[13]), axis=0) dense1_b = dense1_b[:4096] #http://arxiv.org/pdf/1405.3531v4.pdf self.net = NeuralNet( layers=self.layers, conv0_W=np.array(conv0_W), conv0_b=np.array(conv0_b), conv1_W=np.array(conv1_W), conv1_b=np.array(conv1_b), conv2_W=np.array(conv2_W), conv2_b=np.array(conv2_b), conv3_W=np.array(conv3_W), conv3_b=np.array(conv3_b), conv4_W=np.array(conv4_W), conv4_b=np.array(conv4_b), dense0_W=np.array(dense0_W), dense0_b=np.array(dense0_b), dense1_W=np.array(dense1_W), dense1_b=np.array(dense1_b), update_learning_rate=0.015, update=L.updates.nesterov_momentum, update_momentum=0.9, #update=L.updates.sgd, regression=True, verbose=1, eval_size=0.15, objective_loss_function=L.objectives.binary_crossentropy, max_epochs=200) if load_params: print "Loading parameters from ", param_file self.net.load_params_from(param_file) print "TRAINING!" print "input shape: ", X.shape print "output shape: ", y.shape print "Example X", X[0] print "Example Y", y[0] #print self.net.get_params() self.net.fit(X, y) print(self.net.score(X, y)) print "Saving network parameters to ", out_param_file, "..." file = open(out_param_file, 'w+') file.close() self.net.save_weights_to(out_param_file) print "Saving filters to ", filter_file self.write_filters_to_file(filter_file) plt = visualize.plot_loss(self.net) plt.show() plt.savefig(DIR_PROJ + 'loss.png') plt.clf() plt.cla() print "Sample predictions" for i in range(10): pred = self.net.predict(np.array([X[i]])) print "---------------------------------" print i print "prediction", pred print y[i]