def run_BIGRU(timesteps, numclasses, train_x, train_y, train_lens, valid_x, valid_y, valid_lens, test_x, test_y, test_lens, modeldir, batchsize, maxepochs, patience, expsnum): K.set_session(utils.get_session()) print('start class_weights...') class_weights = class_weight.compute_class_weight('balanced', np.unique(train_y), train_y) print(class_weights) train_y = utils.one_hot(train_y, numclasses) valid_y = utils.one_hot(valid_y, numclasses) test_y = utils.one_hot(test_y, numclasses) preds = [] tests = [] epochs = [] print('start...') for exp in range(1, 1 + expsnum): modelfile = modeldir + str(exp) +".hdf5" predict_y, test_y, stopped_epoch = train_model(train_x, train_y, valid_x, valid_y, test_x, test_y, timesteps, numclasses, class_weights, modelfile, batchsize, maxepochs, patience) preds.extend(predict_y) tests.extend(test_y) epochs.append(stopped_epoch) test_yo = np.argmax(tests, 1) pred_yo = np.argmax(preds, 1) target_names = ['Class 1', 'Class 2', 'Class 3', 'Class 4', 'Class 5'] logfile = modeldir + "bigru.log" utils.savemetrics(logfile, epochs, test_yo, pred_yo, target_names)
def test_GRU(timesteps, numclasses, test_x, test_y, test_lens, modeldir, batchsize, expsnum, **kwargs): K.set_session(gpuutils.get_session()) test_y = encode_target(test_y, numclasses) if len(np.shape(test_x))<3: test_x = np.expand_dims(test_x, 2) preds = [] tests = [] paramnums = [] durations = [] for exp in range(1, 1 + expsnum): modelfile = modeldir + str(exp) + ".hdf5" predict_y, test_y, paramnum, duration = test_model(test_x, test_y, timesteps, numclasses, modelfile) preds.extend(predict_y) tests.extend(test_y) paramnums.append(paramnum) durations.append(duration*100.0) test_yo = np.argmax(tests, 1) pred_yo = np.argmax(preds, 1) target_names = ['Class 1', 'Class 2', 'Class 3', 'Class 4', 'Class 5'] logfile = modeldir + "gru.benchmark" savebenchmark(logfile, paramnums, durations, test_yo, pred_yo, target_names)
def run_LSTM(timesteps, numclasses, train_x, train_y, train_lens, valid_x, valid_y, valid_lens, test_x, test_y, test_lens, modeldir, batchsize, maxepochs, patience, expsnum, **kwargs): K.set_session(gpuutils.get_session()) if len(np.shape(train_x)) < 3: train_x = np.expand_dims(train_x, 2) if len(np.shape(valid_x)) < 3: valid_x = np.expand_dims(valid_x, 2) if len(np.shape(test_x)) < 3: test_x = np.expand_dims(test_x, 2) valid_y = encode_target(valid_y, numclasses) test_y = encode_target(test_y, numclasses) preds = [] tests = [] epochs = [] print('start...') unique_y = list(range(numclasses)) if kwargs.get('balancedgenerator') == True: train_dataprovider = gpuutils.SourceGenerator( gpuutils.BalancedGenerator(train_x, train_y, unique_y, int(batchsize / numclasses), True)) else: train_dataprovider = gpuutils.SourceGenerator( gpuutils.RandomGenerator(train_x, train_y, unique_y, batchsize, True)) timesteps = np.shape(train_x)[1] inputdim = np.shape(train_x)[2] train_steps_per_epoch = int(np.shape(train_x)[0] / batchsize) for exp in range(1, 1 + expsnum): modelfile = modeldir + str(exp) + ".hdf5" predict_y, test_y, stopped_epoch = train_model( timesteps, inputdim, train_dataprovider, train_steps_per_epoch, valid_x, valid_y, test_x, test_y, timesteps, numclasses, modelfile, batchsize, maxepochs, patience) preds.extend(predict_y) tests.extend(test_y) epochs.append(stopped_epoch) test_yo = np.argmax(tests, 1) pred_yo = np.argmax(preds, 1) target_names = ['Class 1', 'Class 2', 'Class 3', 'Class 4', 'Class 5'] logfile = modeldir + "lstm.log" savemetrics(logfile, epochs, test_yo, pred_yo, target_names)
def onJsonInput(self, jsonInput): #build the result object result = {'prediction':-1} #prepare the input x_raw = [jsonInput['pixels']] x_raw = np.reshape(x_raw, (1, 28, 28)) ue.log('image shape: ' + str(x_raw.shape)) #ue.log(stored) #convert pixels to N_samples, height, width, N_channels input tensor x = np.reshape(x_raw, (len(x_raw), 28, 28, 1)) ue.log('input shape: ' + str(x.shape)) #run run the input through our network if self.model is None: ue.log("Warning! No 'model' found. Did training complete?") return result #restore our saved session and model K.set_session(self.session) with self.session.as_default(): output = self.model.predict(x) ue.log(output) #convert output array to prediction index, value = max(enumerate(output[0]), key=operator.itemgetter(1)) result['prediction'] = index result['pixels'] = jsonInput['pixels'] #unnecessary but useful for round tripping return result
def test_BIGRU(timesteps, numclasses, test_x, test_y, test_lens, modeldir, expsnum): K.set_session(utils.get_session()) test_y = utils.one_hot(test_y, numclasses) preds = [] tests = [] paramnums = [] durations = [] for exp in range(1, 1 + expsnum): modelfile = modeldir + str(exp) + ".hdf5" predict_y, test_y, paramnum, duration = test_model(test_x, test_y, timesteps, numclasses, modelfile) preds.extend(predict_y) tests.extend(test_y) paramnums.append(paramnum) durations.append(duration) test_yo = np.argmax(tests, 1) pred_yo = np.argmax(preds, 1) target_names = ['Class 1', 'Class 2', 'Class 3', 'Class 4', 'Class 5'] logfile = modeldir + "bigru.benchmark" utils.savebenchmark(logfile, paramnums, durations, test_yo, pred_yo, target_names)
import tensorflow as tf from tensorflow.contrib.keras import backend as K config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.5 config.gpu_options.visible_device_list = "0" K.set_session(tf.Session(config=config)) from AlphagoZero.training.evaluator import run_evaluate run_evaluate()
placeholder_dict = datapipeline.get_placeholder_dict() feed_dict_train = datapipeline.get_feed_dict(mode=TRAIN) feed_dict_val = datapipeline.get_feed_dict(mode=VALIDATION) feed_dict_test = datapipeline.get_feed_dict(mode=TEST) sparse_model_params = SparseModelParams( num_elements=datapipeline.num_elements, feature_size=datapipeline.feature_size ) model = select_model(model_name=model_params.model_name)( model_params = model_params, sparse_model_params = sparse_model_params, placeholder_dict = placeholder_dict ) sess = tf.Session() K.set_session(sess) sess.run(tf.global_variables_initializer()) for epoch in range(model_params.epochs): start_time = time() loss, accuracy, opt = sess.run([model.loss, model.accuracy, model.optimizer_op], feed_dict=feed_dict_train) loss_val, accuracy_val = sess.run([model.loss, model.accuracy], feed_dict=feed_dict_test) print(accuracy_val) # print(accuracy)
def run_convnet(params): HYPER = make_hyper(params) image_folder = params.image_folder raw_data_folder = params.raw_data_folder image_features_folder = params.vgg16_folder logger = HYPER.logger df = get_df(params) if df.shape[0] == 0: logger.info('No images remaining to process. All done.') else: logger.info('Processing %d images.', df.shape[0]) logger.info('\n#################### Args: ####################\n%s', params.pformat()) logger.info( '##################################################################\n') logger.info( '\n######################### HYPER Params: #########################\n%s', HYPER.pformat()) logger.info( '##################################################################\n') b_it = BatchImageIterator2(raw_data_folder, image_folder, HYPER, image_processor=ImagenetProcessor(HYPER), df=df, num_steps=params.num_steps, num_epochs=params.num_epochs) graph = tf.Graph() with graph.as_default(): config = tf.ConfigProto(log_device_placement=False) config.gpu_options.allow_growth = True tf_session = tf.Session(config=config) with tf_session.as_default(): K.set_session(tf_session) tf_im = tf.placeholder(dtype=HYPER.dtype, shape=((HYPER.B, ) + HYPER.image_shape), name='image') with tf.device( '/gpu:1'): # change this to gpu:0 if you only have one gpu tf_a_batch = build_vgg_context(HYPER, tf_im) tf_a_list = tf.unstack(tf_a_batch, axis=0) t_n = tfc.printVars('Trainable Variables', tf.trainable_variables()) g_n = tfc.printVars('Global Variables', tf.global_variables()) l_n = tfc.printVars('Local Variables', tf.local_variables()) assert t_n == g_n assert g_n == l_n print '\nUninitialized params' print tf_session.run(tf.report_uninitialized_variables()) print 'Flushing graph to disk' tf_sw = tf.summary.FileWriter(tfc.makeTBDir(HYPER.tb), graph=graph) tf_sw.flush() print '\n' start_time = time.clock() for step, b in enumerate(b_it, start=1): # if b.epoch > 1 or (params.num_steps >= 0 and step > params.num_steps): # break feed_dict = {tf_im: b.im, K.learning_phase(): 0} a_list = tf_session.run(tf_a_list, feed_dict=feed_dict) assert len(a_list) == len(b.image_name) for i, a in enumerate(a_list): ## print 'Writing %s, shape=%s'%(b.image_name[i], a.shape) with open( os.path.join( image_features_folder, os.path.splitext(b.image_name[i])[0] + '.pkl'), 'wb') as f: pickle.dump(a, f, pickle.HIGHEST_PROTOCOL) if step % 10 == 0: print('Elapsed time for %d steps = %d seconds' % (step, time.clock() - start_time)) print('Elapsed time for %d steps = %d seconds' % (step, time.clock() - start_time)) print 'done'
# Define the SSD model. reuse = True if 'ssd_net' in locals() else None ssd_net = ssd_vgg_300.SSDNet() with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)): #predictions, localisations, logits, end_points = ssd_net.net(image_4d, is_training=False, reuse=reuse) predictions, localisations, logits, end_points = ssd_net.net( vis_img_input, is_training=False, reuse=reuse) # Restore SSD model. ckpt_filename = 'checkpoints/ssd_300_vgg.ckpt' # ckpt_filename = '../checkpoints/VGG_VOC0712_SSD_300x300_ft_iter_120000.ckpt' isess.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(isess, ckpt_filename) K.set_session(isess) K.manual_variable_initialization(True) # SSD default anchor boxes. ssd_anchors = ssd_net.anchors(net_shape) # ## Post-processing pipeline # # The SSD outputs need to be post-processed to provide proper detections. Namely, we follow these common steps: # # * Select boxes above a classification threshold; # * Clip boxes to the image shape; # * Apply the Non-Maximum-Selection algorithm: fuse together boxes whose Jaccard score > threshold; # * If necessary, resize bounding boxes to original image shape. # In[7]:
import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data from tensorflow.contrib.keras import backend as K from tensorflow.contrib.keras import layers K.set_session(tf.get_default_session()) img = tf.placeholder(tf.float32, shape=(None, 784)) x = layers.Dense(128, activation='relu')(img) print x.trainable_weights x = layers.Dropout(0.5)(x) x = layers.Dense(128, activation='relu')(x) x = layers.Dropout(0.5)(x) preds = layers.Dense(10, activation='softmax')(x) labels = tf.placeholder(tf.int32) loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=preds, labels=labels)) mnist_data = input_data.read_data_sets("MNIST_data", one_hot=False) optimize = tf.train.RMSPropOptimizer(0.001).minimize(loss) acc = tf.reduce_mean(tf.cast(tf.not_equal(tf.cast(tf.argmax(preds, 1), tf.int32), labels), tf.float32)) init_op = tf.global_variables_initializer() with tf.Session().as_default() as sess:
def run(model_params, data_dir, dataset_name, experiment=None): datapipeline = DataPipelineAE(model_params=model_params, data_dir=data_dir, dataset_name=dataset_name) feed_dict_train = datapipeline.get_feed_dict(mode=TRAIN) feed_dict_val = datapipeline.get_feed_dict(mode=VALIDATION) feed_dict_test = datapipeline.get_feed_dict(mode=TEST) sparse_model_params = datapipeline.get_sparse_model_params() autoencoder_model_params = datapipeline.get_autoencoder_model_params() placeholder_dict = datapipeline.get_placeholder_dict() if (experiment): experiment.add_config(sparse_model_params.get_variables()) experiment.add_config(autoencoder_model_params.get_variables()) sess = tf.Session() K.set_session(sess) train_loss_runs = [] validation_loss_runs = [] test_aucscore_runs = [] test_apr_runs = [] for num_exp in range(model_params.num_exp): model = select_model(model_name=model_params.model_name)( model_params=model_params, sparse_model_params=sparse_model_params, placeholder_dict=placeholder_dict, autoencoder_model_params=autoencoder_model_params) if (model_params.tensorboard_logs_dir): train_writer = tf.summary.FileWriter( model_params.tensorboard_logs_dir + model_params.model_name + "/" + TRAIN, sess.graph) val_writer = tf.summary.FileWriter( model_params.tensorboard_logs_dir + model_params.model_name + "/" + VALIDATION, sess.graph) sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) train_loss_list = [] validation_loss_list = [] test_aucscore_list = [] test_apr_list = [] for epoch in range(model_params.epochs): loss, accuracy, opt, summary = sess.run([ model.loss, model.accuracy, model.optimizer_op, model.summary_op ], feed_dict=feed_dict_train) loss_val, accuracy_val, summary_val = sess.run( [model.loss, model.accuracy, model.summary_op], feed_dict=feed_dict_val) if (model_params.tensorboard_logs_dir): train_writer.add_summary(summary, epoch) val_writer.add_summary(summary_val, epoch) embedding, predictions_test, labels_test, mask_test, loss_test, accuracy_test, summary_test = sess.run( [ model.embeddings, model.logits, model.labels, model.mask, model.loss, model.accuracy, model.summary_op ], feed_dict=feed_dict_test) auc_score = compute_auc_score(labels=labels_test, predictions=predictions_test, mask=mask_test) test_aucscore_list.append(auc_score) apr = compute_average_precision_recall( labels=labels_test, predictions=predictions_test, mask=mask_test) test_apr_list.append(apr) train_loss_list.append(loss) validation_loss_list.append(loss_val) print( "For epoch:run {}:{}, training_loss = {}, validation_loss = {}, test_auc = {}, test_apr = {}" .format(epoch, num_exp, loss, loss_val, auc_score, apr)) train_loss_runs.append(train_loss_list) validation_loss_runs.append(validation_loss_list) test_aucscore_runs.append(test_aucscore_list) test_apr_runs.append(test_apr_list) plot_loss_curves(train_loss_runs, validation_loss_runs, dataset_name=dataset_name, model_params=model_params) print_stats(train_loss_runs, validation_loss_runs, test_metrics=[test_aucscore_runs, test_apr_runs], test_metrics_labels=[AUCSCORE, AVERAGE_PRECISION_RECALL_SCORE])
K.clear_session() return cg def h5_to_pb(h5, pb): write_graph(constantize(h5), pb) def copy_perms(source, target): st = os.stat(source) os.chown(target, st[stat.ST_UID], st[stat.ST_GID]) if __name__ == "__main__": # disable gpu for conversion config = tf.ConfigProto(allow_soft_placement=True, device_count={ 'CPU': 1, 'GPU': 0 }) session = tf.Session(config=config) K.set_session(session) import sys if len(sys.argv) < 3: print('usage: {} <src_fname> <dst_fname>'.format(sys.argv[0])) sys.exit(1) h5_to_pb(sys.argv[1], sys.argv[2]) copy_perms(sys.argv[1], sys.argv[2]) print('saved the constant graph (ready for inference) at: ', sys.argv[2])
def run(model_params, data_dir, dataset_name, experiment=None): datapipeline = DataPipeline(model_params=model_params, data_dir=data_dir, dataset_name=dataset_name) placeholder_dict = datapipeline.get_placeholder_dict() feed_dict_train = datapipeline.get_feed_dict(mode=TRAIN) feed_dict_val = datapipeline.get_feed_dict(mode=VALIDATION) feed_dict_test = datapipeline.get_feed_dict(mode=TEST) sparse_model_params = SparseModelParams( num_elements=datapipeline.num_elements, feature_size=datapipeline.feature_size) if (experiment): experiment.add_config(sparse_model_params.get_variables()) sess = tf.Session() K.set_session(sess) train_loss_runs = [] validation_loss_runs = [] test_accuracy_runs = [] model = None for _ in range(model_params.num_exp): model = select_model(model_name=model_params.model_name)( model_params=model_params, sparse_model_params=sparse_model_params, placeholder_dict=placeholder_dict) if (model_params.tensorboard_logs_dir): train_writer = tf.summary.FileWriter( model_params.tensorboard_logs_dir + model_params.model_name + "/" + TRAIN, sess.graph) val_writer = tf.summary.FileWriter( model_params.tensorboard_logs_dir + model_params.model_name + "/" + VALIDATION, sess.graph) sess.run(tf.global_variables_initializer()) train_loss_list = [] validation_loss_list = [] test_accuracy_list = [] for epoch in range(model_params.epochs): loss, accuracy, opt, summary = sess.run([ model.loss, model.accuracy, model.optimizer_op, model.summary_op ], feed_dict=feed_dict_train) loss_val, accuracy_val, summary_val = sess.run( [model.loss, model.accuracy, model.summary_op], feed_dict=feed_dict_val) if (model_params.tensorboard_logs_dir): train_writer.add_summary(summary, epoch) val_writer.add_summary(summary_val, epoch) train_loss_list.append(loss) validation_loss_list.append(loss_val) accuracy_test = sess.run([model.accuracy], feed_dict=feed_dict_test) test_accuracy_list.append(accuracy_test) train_loss_runs.append(train_loss_list) validation_loss_runs.append(validation_loss_list) test_accuracy_runs.append(test_accuracy_list) plot_loss_curves(train_loss_runs, validation_loss_runs, dataset_name=dataset_name, model_params=model_params) print_stats(train_loss_runs, validation_loss_runs, test_metrics=[test_accuracy_runs], test_metrics_labels=[ACCURACY]) activations, khot_labels, mask = sess.run( [model.activations, model.labels, model.mask], feed_dict=feed_dict_train) embedd_and_plot(node_representation=activations[-2], labels=khot_labels, mask=mask)