def dsd(config): model = dict() model = cnn.cnn(model, config, 'cnn') model = rnn.rnn(model, config, 'rnn', 'cnn') model = ctc.ctc(model, config, 'ctc', 'rnn') model = fnn.fnn(model, config, 'fnns', 'rnn') model = ctc.ctc(model, config, 'ctc', 'fnns') model = fnn.fnn(model, config, 'fnnd', 'rnn') model = ces.ces(model, config, 'ces', 'fnnd') model = dia.dia(model, config, 'dia', 'fnnd', 'rnn') model = ced.ced(model, config, 'ced', 'dia') model['loss'] = model['ctc_loss'] model['step'] = tf.Variable(0, trainable=False, name='step') model['lrate'] = tf.train.exponential_decay( config.getfloat('global', 'lrate'), model['step'], config.getint('global', 'dstep'), config.getfloat('global', 'drate'), staircase=False, name='lrate') model['optim'] = getattr(tf.train, config.get('global', 'optim'))( model['lrate']).minimize(model['loss'], global_step=model['step'], name='optim') return model
def __init__(self): self.conf_ = conf() pre_processor_ = pre_processor() train_x, train_y, val_x, val_y = pre_processor_.get_data() # Build Computation Graph self.cnn = cnn() self.cnn.forward_prop() self.cnn.compute_loss() self.cnn.compute_acc() self.cnn.back_prop() # initialize tensors self.sess = tf.Session() self.sess.run(tf.global_variables_initializer()) self.sess.run(tf.local_variables_initializer()) logging.info("training...") self.saver = tf.train.Saver(max_to_keep=1) for epoch in range(self.cnn.epochs): iters = int(len(train_x) / self.cnn.batch_size) for iter_ in range(iters): # extract batch data batch_x = train_x[iter_ * self.cnn.batch_size:(iter_ + 1) * self.cnn.batch_size, :] batch_y = train_y[iter_ * self.cnn.batch_size:(iter_ + 1) * self.cnn.batch_size, :] # train self.sess.run(self.cnn.tf_train, feed_dict={ self.cnn.tf_X: batch_x, self.cnn.tf_y: batch_y }) # train loss _, loss_train, acc_train = self.cnn.analyze_epoch( train_x, train_y, self.sess) # val loss _, loss_val, acc_val = self.cnn.analyze_epoch( val_x, val_y, self.sess) # save model _ = self.saver.save(self.sess, "../models/sess", global_step=int(epoch + 1)) # log the performance at each epoch logging.info( "epoch: {0}, loss_train: {1}, acc_train: {2}, loss_val: {3}, acc_val: {4}" .format(epoch + 1, loss_train, acc_train, loss_val, acc_val)) self.sess.close()
def __init__(self): self.win = tk.Tk() self.button_dict = {} self.actions_list = ['*', '/', '+', '-', '.', '='] self.EQUAL_SIGN = '=' self.DOT_SIGN = '.' self.recent_action = "n" self.mySVM = learner.Learner() self.my_cnn = cnn.cnn()
def main(): nb_epochs = 50 nb_train_samples = 4000 + 3840 #3840 pedestrian - 4000 notPedestrian nb_validation_samples = 1000 + 960 #960 pedestrian/ 1000 notPedestrian images_dim = 18, 36 # heigths = 36, width = 18 model = cnn(images_dim) train(model, nb_epochs, nb_train_samples, nb_validation_samples, images_dim)
def ds2(config): model = dict() model = cnn.cnn(model, config, 'cnn') model = rnn.rnn(model, config, 'rnn', 'cnn') model = fnn.fnn(model, config, 'fnn', 'rnn') model = ctc.ctc(model, config, 'ctc', 'fnn') model['loss'] = model['ctc_loss'] model['step'] = tf.Variable(0, trainable = False, name = 'step') model['lrate'] = tf.train.exponential_decay(config.getfloat('global', 'lrate'), model['step'], config.getint('global', 'dstep'), config.getfloat('global', 'drate'), staircase = False, name = 'lrate') model['optim'] = getattr(tf.train, config.get('global', 'optim'))(model['lrate']).minimize(model['loss'], global_step = model['step'], name = 'optim') return model
def run_cnn(): cnn_obj = cnn(data_path) # Flag makes it run with new simplified code and does not run validation accuracy for quicker response legacy_run = False training = True ''' WE NEED THIS FOR LOOKING AT HEAT MAP OVER IMAGE''' single_layer_fnn = True ## GET INPUT DATA # input_data = nn_utilities_obj.prepare_digits_image_inputs() # input_data = nn_utilities_obj.load_mnist_digit_data() # input_data = nn_utilities_obj.load_emnist_alphadigit_data() # input_data = nn_utilities_obj.load_emnist_letters_data() # input_data = nn_utilities_obj.load_fashion_data() input_data = nn_utilities_obj.load_PneumothoraxDataset() ## Override the default learning rate cnn_obj.learning_rate_var = 0.0001 ## 2 LAYER FNN INPUTS hiddenlayer_1_width = 500 hiddenlayer_2_width = 500 ## Assuming it's a SQUARE IMAGE image_height = int(np.sqrt(input_data["x_train"].shape[1])) image_width = image_height if legacy_run == True: ## CREATE CNN & DNN MODEL optimizer, cost, accuracy, cnn_fnn_model = cnn_obj.create_model( [image_height, image_width], hiddenlayer_1_width, hiddenlayer_2_width, input_data["y_train"].shape[1], single_layer_fnn) else: ## CREATE CNN & DNN MODEL optimizer, cost, accuracy, cnn_fnn_model = cnn_obj.create_simplified_model( [image_height, image_width], hiddenlayer_1_width, hiddenlayer_2_width, input_data["y_train"].shape[1], single_layer_fnn) ## TRAIN THE MODEL AND TEST PREDICTION run_nn(cnn_obj, input_data, optimizer, cost, accuracy, cnn_fnn_model, "cnn\\" + input_data["name"] + "\\" + input_data["name"], True, training)
def __init__(self, data, epochs, batch_size, training_ratio, sequance_length, lstmCells=10, LSTMDL1units=20, LSTMDL2units=5, LSTMDL3units=1, CL1filters=1, CL1kernal_size=2, CL1strides=1, PL1pool_size=1, CNNDL1units=20, CNNDL2units=5, CNNDL3units=1, lstmWeight=0.5, cnnWeight=0.5, learningRate=0.001): self.lstm_model = lstm.lstm(data=data, epochs=epochs, batch_size=batch_size, training_ratio=training_ratio, sequance_length=sequance_length, lstmCells=lstmCells, learningRate=learningRate) self.cnn_model = cnn.cnn(data=data, epochs=epochs, batch_size=batch_size, training_ratio=training_ratio, sequance_length=sequance_length, CL1filters=CL1filters, CL1kernal_size=CL1kernal_size, CL1strides=CL1strides, PL1pool_size=PL1pool_size, DL1units=CNNDL1units, DL2units=CNNDL2units, DL3units=CNNDL3units, learningRate=learningRate) self.lstmWeight = lstmWeight self.cnnWeight = cnnWeight
def get_model(self, model_type, parameters): if model_type == "multi_arma": return arma(parameters=parameters) elif model_type == "multi_arima": return arima(parameters=parameters) elif model_type == "multi_lstm": return lstm(parameters=parameters) elif model_type == "multi_cnn": return cnn(parameters=parameters) elif model_type == "multi_lstmcnn": return lstmcnn(parameters=parameters) elif model_type == "multi_lstmcnn_kerascombinantion": return lstmcnn_kerascombinantion(parameters=parameters)
def main(): print("Opening data & labels") train_set, train_labels = ld.get_train_set(img_width=128, img_height=128) test_set, test_labels = ld.get_test_set(img_width=128, img_height=128) test_set = reshape(test_set) test_labels = reshape(test_labels) train_labels = reshape(train_labels) train_set = reshape(train_set) print("Open Model") epochs = 10 batch_size = 16 weights = "model.hdf5" if os.path.exists(weights): my_cnn = load_model(weights) else: my_cnn = cnn.cnn(img_width=128, img_height=128) if train: # checkpoint filepath = "out/weights-improvement-{epoch:02d}-{val_acc:.2f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max') callbacks_list = [checkpoint] # train history = my_cnn.fit( x=train_set, # Input should be (train_cases, 128, 128, 1) y=train_labels, batch_size=batch_size, epochs=epochs, verbose=2, callbacks=callbacks_list, validation_data=(test_set, test_labels)) cnn.plot_val_acc(history=history) # Confusion Matrix Y_pred = my_cnn.predict_classes(test_set) # Y_pred_classes = np.argmax(Y_pred, axis=1) # import pdb; pdb.set_trace() confusion_mtx = confusion_matrix(test_labels, Y_pred) cnn.plot_confusion_matrix(confusion_mtx, classes=list(dict_characters.values())) import pdb pdb.set_trace()
def main(): name = sys.argv[1] batch_size = sys.argv[2] end_epoch = sys.argv[3] hidden_units = sys.argv[4] hidden_layers = sys.argv[5] Sampling = sys.argv[6] X_train_path = sys.argv[7] Y_train_path = sys.argv[8] eval_path = sys.argv[9] if str(name) == 'sln': feed_forward = sln.ff(name,batch_size,hidden_units,1,end_epoch) feed_forward.run(Sampling,X_train_path,Y_train_path, eval_path) elif name == 'cnn': cnn_net = cn.cnn(name,batch_size,hidden_units,1,end_epoch) cnn_net.run(Sampling,X_train_path,Y_train_path, eval_path) elif name == 'mln': feed_forward = mln.ff(name,batch_size,hidden_units,hidden_layers,end_epoch) feed_forward.run(Sampling,X_train_path,Y_train_path, eval_path)
def __init__(self, parameters): lstm_parmeters = { # for all "data":parameters["data"], "training_ratio":parameters["training_ratio"], "no_of_prediction_points":parameters["no_of_prediction_points"], # for LSTM "epochs":parameters["epochs"], "batch_size":parameters["batch_size"], "sequance_length":parameters["sequance_length"], "DL1units":parameters["LSTMDL1units"], "DL2units":parameters["LSTMDL2units"], "DL3units":parameters["LSTMDL3units"], "lstmCells":parameters["lstmCells"], } self.lstm_model = lstm(lstm_parmeters) cnn_parmeters = { # for all "data":parameters["data"], "training_ratio":parameters["training_ratio"], "no_of_prediction_points":parameters["no_of_prediction_points"], # for LSTM "epochs":parameters["epochs"], "batch_size":parameters["batch_size"], "sequance_length":parameters["sequance_length"], "DL1units":parameters["CNNDL1units"], "DL2units":parameters["CNNDL2units"], "DL3units":parameters["CNNDL3units"], "CL1filters":parameters["CL1filters"], "CL1kernal_size":parameters["CL1kernal_size"], "CL1strides":parameters["CL1strides"], "PL1pool_size":parameters["PL1pool_size"], } self.cnn_model = cnn(cnn_parmeters) self.lstmWeight = parameters["lstmWeight"] self.cnnWeight = parameters["cnnWeight"] self.no_of_prediction_points = parameters["no_of_prediction_points"]
def main(): for line in open('dataset_www2018_rand.txt'): line = line.strip().split('\t') hashtag = line[0] active_period = int(line[1]) htg_acpd_dict[hashtag] = active_period hashtag_trainingset = get_trainingset_hashtag() print '!!!\nhashtags of the trainingset have been picked out.\n!!!' target = tf.placeholder(tf.float32, [None, num_classes]) lstm_data = tf.placeholder(tf.float32, [None, lstm_max_length, num_lstm_features]) lstm_sequence_length_vector = tf.placeholder(tf.int32, [None]) lstm_dropout = tf.placeholder(tf.float32) lstm_output = lstm.lstm(lstm_data, lstm_sequence_length_vector, lstm_dropout) cnn_data = tf.placeholder(tf.float32, [None, None]) reshape_cnn_data = tf.reshape(data,[-1,1,100,1]) cnn_output = cnn.cnn(reshape_cnn_data) #getcountlengthembeddings part length_and_count length_and_count_embeddings = get_length_and_count_embeddings() prediction_output = overall_prediction(lstm_output, cnn_output, length_and_count_embeddings) cost_output = cost(prediction_output,target) optimizer_output = optimizer(cost) sess = tf.Session() sess.run(tf.global_variables_initializer()) for epoch in range(num_epochs): np.random.shuffle(hashtag_trainingset) mse_sum = 0 for i in range(num_iterations):
def get_doc_repr(): nonlocal d_region, max_jump_offset, word_vector_dim, separate, d_offset, doc_arch, doc_after_pool_size d_region = tf.pad( d_region, [[0, 0], [0, max_jump_offset - tf.shape(d_region)[1]], [0, 0]], 'CONSTANT', constant_values=0) d_region.set_shape([None, max_jump_offset, word_vector_dim]) with vs.variable_scope('DocCNN' if separate else 'CNN'): doc_dpool_index = DynamicMaxPooling.dynamic_pooling_index_1d( d_offset, max_jump_offset) doc_repr = cnn(d_region, architecture=doc_arch, activation='relu', dpool_index=doc_dpool_index) with vs.variable_scope('LengthOrderAwareMaskPooling'): mask_prob = tf.minimum( tf.ceil(doc_after_pool_size**2 / dq_size[:, 0]), doc_after_pool_size) / 50 # length-aware mask mask_ber = tf.distributions.Bernoulli(probs=mask_prob) mask = tf.transpose(mask_ber.sample([doc_after_pool_size]), [1, 0]) # order-aware pooling #mask_for_zero = tf.cast(tf.expand_dims(tf.range(doc_after_pool_size), axis=0) < \ # (doc_after_pool_size - tf.reduce_sum(mask, axis=1, keep_dims=True)), dtype=tf.int32) #mask = tf.cast(tf.concat([mask, mask_for_zero], axis=1), dtype=tf.bool) #doc_repr = tf.boolean_mask(tf.concat([doc_repr, tf.zeros_like(doc_repr)], axis=1), mask) #doc_repr = tf.reshape(doc_repr, [bs, doc_after_pool_size, doc_arch[-2][-1]]) # normal pooling doc_repr = doc_repr * tf.cast( tf.expand_dims(mask, axis=-1), dtype=tf.float32) # pooling doc_repr = tf.layers.max_pooling1d(doc_repr, pool_size=[5], strides=[5], padding='SAME', name='pool') return doc_repr
def __init__(self): #TODO take in the settings file self.cnn_input_obj = cnn_input() self.cnn_obj = cnn() self.power_map_file = "./work/current_map_processed.csv" self.cong_map_file = "./output/congestion_map.csv" #congestion_map_file = "./work/congestion_processed.csv" self.settings_obj = T6_PSI_settings.load_obj() if (len(sys.argv)>1 and sys.argv[1] == "no_congestion"): self.congestion_enabled = 0 else: self.congestion_enabled = 1 if self.congestion_enabled ==1: self.checkpoint_dir = self.settings_obj.checkpoint_dir else: self.checkpoint_dir = self.settings_obj.checkpoint_dir_wo_cong normalization_file = self.checkpoint_dir+self.settings_obj.normalization_file # Golden template numbers needed for comparison # This corresponds only to the first current map #indices = np.zeros((self.settings_obj.NUM_REGIONS_X * self.settings_obj.NUM_REGIONS_Y)) self.test_size = self.settings_obj.NUM_REGIONS_X * self.settings_obj.NUM_REGIONS_Y # Hard coded after seeing training data, need to fix with open(normalization_file) as f: norm_data = json.load(f) min_cur = norm_data['currents']['min'] max_cur = norm_data['currents']['max'] self.scl_cur = 1 / (max_cur - min_cur) if self.congestion_enabled == 1: min_cong = norm_data['congestion']['min'] max_cong = norm_data['congestion']['max'] self.scl_cong = 1 / (max_cong - min_cong) self.template_map_file = "./output/template_map.txt"
def main(_): # ### Create the multimnist set. # create_multimnist(is_training=cfg.is_training) # trX, trY, num_tr_batch, valX, valY, num_val_batch = load_multimnist(is_training=cfg.is_training) # while True: # index = np.random.randint(550000) # print(trY[index]) # plt.imshow(np.squeeze(trX[index])) # plt.show() # sys.exit() # The number of labels for the data. num_label = 10 # Generate the model. tf.logging.info('Loading Graph...') if cfg.use_cnn == True: model = cnn() else: model = CapsNet() tf.logging.info('Graph loaded') # Generate the supervisor. sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) # Run training or evaluation. if cfg.is_training: tf.logging.info('Start training') train(model, sv, num_label) tf.logging.info('Training done') else: tf.logging.info('Start evaluation') evaluation(model, sv, num_label) tf.logging.info('Evaluation done')
def get_query_repr(): nonlocal q_region, max_jump_offset, word_vector_dim, separate, q_offset, query_arch q_region = tf.pad( q_region, [[0, 0], [0, max_jump_offset - tf.shape(q_region)[1]], [0, 0]], 'CONSTANT', constant_values=0) q_region.set_shape([None, max_jump_offset, word_vector_dim]) with vs.variable_scope('QueryCNN' if separate else 'CNN'): if not separate: vs.get_variable_scope().reuse_variables() query_dpool_index = DynamicMaxPooling.dynamic_pooling_index_1d( q_offset, max_jump_offset) query_repr = cnn(q_region, architecture=query_arch, activation='relu', dpool_index=query_dpool_index) query_repr = tf.layers.max_pooling1d(query_repr, pool_size=[10], strides=[10], padding='SAME', name='pool') return query_repr
def __init__(self): # load network configuration self.conf_ = conf() # get test data pre_proc = pre_processor() test_x, test_y = pre_proc.get_data(testing=True) self.sess = tf.Session() # Build Computation Graph self.cnn = cnn() meta_filepath = "../models/sess-" + str(self.cnn.epochs) + ".meta" ckpt_filepath = "../models/sess-" + str(self.cnn.epochs) self.cnn.forward_prop(testing=True, sess=self.sess, meta_filepath=meta_filepath, ckpt_filepath=ckpt_filepath) self.cnn.compute_loss() self.cnn.compute_acc() # Initialize local variables only (not global variables) self.sess.run(tf.local_variables_initializer()) # start testing self.start(test_x, test_y)
# # result_path = '/home/jdwang/corprocessor/coprocessor/word2vec/20160325/output/20160329#2/20160326#1#2.csv' # # test_corpus[['seg_pos','pred']].to_csv(result_path,sep='\t') if __name__ == '__main__': print 'load data...' corpus = load_train_data() print 'split data to fit and test set...' train_corpus,test_corpus = split_train_test(corpus,train_size=0.7) # save_train_test_corpus(train_corpus,test_corpus) print 'finished...' # print train_corpus.head() # print test_corpus.head() # print train_corpus.shape[0] # print test_corpus.shape[0] train_X = np.array([ item for item in train_corpus['vector'].as_matrix()]) train_y = train_corpus['label'].as_matrix() # print train_X.shape # print train_y.dtype test_X = np.array([ item for item in test_corpus['vector'].as_matrix()]) test_y = test_corpus['label'].as_matrix() # lr() # cnn_model.sgd_optimization(50, len(which_file), train_X, train_y,train_X, train_y) cnn.cnn(train_X, train_y, (train_X.shape[0], 1, 50, 1), (5, 1, 5, 1))
from load import dataset from cnn import cnn train_x, train_y = dataset(onehot = True) cnn(train_x, train_y)
def web_scraper(input): key_words = input.split(',') keys = [] #dates = [] time = str(datetime.datetime.now().date()) for key_word in key_words: try: while (key_word[0] == ' '): key_word = key_word[1:] while (key_word[len(key_word) - 1] == ' '): key_word = key_word[:-1] except IndexError: continue if (len(key_word) == 0): continue inputs = key_word.split(' ') key = '' for i in inputs: key += i key += '%20' key = key[:-3].lower() key = re.sub(r'[ ]+', ' ', key) keys.append(key) #dates.append(check.check_date(data_base, kkeys[i])) for i in range(0, len(keys)): previous_len = 0 try: for lines in open("./documents/web/Articles.bank", 'r', encoding='utf-8'): previous_len += 1 except FileNotFoundError: pass stored_keys = check.load_keywords_info() data_base = check.load_url_info() data_print = {} kkey = fmt.file_name(keys[i], '_') for kk in stored_keys: if abs(len(kkey) - len(kk)) < 2 and check.MinEditDist(kkey, kk) == 1: kkey = kk if kkey in stored_keys: date = int(re.sub(r'-', '', stored_keys[kkey])) else: date = 0 stored_keys[kkey] = time if kkey not in data_base: data_base[kkey] = [] cnn.cnn(data_base, data_print, keys[i], date, previous_len) foxnews.foxnews(data_base, data_print, keys[i], date, previous_len) cbs.cbs(data_base, data_print, keys[i], date, previous_len) politico.politico(data_base, data_print, keys[i], date, previous_len) #washington_post.washington_post(data_base,data_print,key,date) if len(data_print) > 1: check.save_keywords_info(stored_keys) check.save_url_info(data_base) output_file.output(data_print, data_base, previous_len) print("Update date: " + time)
import cv2 import sys import os import cnn for img_path in sys.argv[1:]: if (os.path.isfile(img_path) == False): try: raise FileNotFoundError('no such file') except FileNotFoundError: raise image = cv2.imread(img_path, 0) di_path = "./traind_model/" cnn_model = cnn.cnn(40, di_path + "model_40px") cnn.predict(image)
def main(): if args.arch not in {'lstm', 'mdlstm', 'cnn'}: raise Exception( 'not support arch type (should be one of "lstm", "mdlstm", "cnn").' ) # config visualization = 'saliency' # kernel, saliency learning_rate = 0.001 * 0.5 anisotropy = False distribution = 'power_law' mean_match_query_term = 3 mean_match_count = 5 batch_size = 256 h = 5 w = 10 channels = 1 hidden_size = 50 mean_match_doc_term = max( 1, int(mean_match_count * h / mean_match_query_term)) cnn_arch = [[3, 3, 1, 16], [1, 2, 2, 1], [3, 3, 16, 32], [1, 2, 2, 1], [2, 2, 32, 64], [1, 2, 2, 1]] #cnn_arch = [[3, 3, 1, 1], [1, 1, 1, 1]] cnn_activation = 'relu' # graph #grad_debugger = tf_debug.GradientsDebugger() #if args.tf_summary: # global_step = tf.train.get_or_create_global_step() # summary_writer = tf.contrib.summary.create_file_writer(args.tf_summary_path, flush_millis=10000) tf.set_random_seed(SEED) x = tf.placeholder(tf.float32, [None, h, w, channels]) y = tf.placeholder(tf.float32, [None, h, w, channels]) x_w = tf.placeholder(tf.float32, [None, h, w]) bs = tf.shape(x)[0] #with summary_writer.as_default(), tf.contrib.summary.always_record_summaries(): if args.arch == 'mdlstm': print('Using Multi Dimensional LSTM !') if args.rnn_type == 'dynamic': nn_out, rnn_states = multi_dimensional_rnn_while_loop( rnn_size=hidden_size, input_data=x, sh=[1, 1]) elif args.rnn_type == 'static': nn_out, rnn_states = multi_dimensional_rnn_static( rnn_size=hidden_size, input_data=x, sh=[1, 1]) #debug_rnn_states = grad_debugger.identify_gradient(rnn_states) elif args.arch == 'lstm': print('Using Standard LSTM !') nn_out = standard_lstm(input_data=x, rnn_size=hidden_size) elif args.arch == 'cnn': print('Using CNN !') nn_out = cnn(x, architecture=cnn_arch, activation=cnn_activation) nn_out = tf.reshape(nn_out, (bs, int(np.prod(nn_out.get_shape()[1:])))) # linear transformation (no activation) model_out = slim.fully_connected(inputs=nn_out, num_outputs=1, activation_fn=None) if args.arch == 'cnn': loss = 1e4 * tf.reduce_sum(tf.abs( tf.reshape(tf.boolean_mask(y, tf.expand_dims(x_w, axis=-1) > 0), [bs, 1]) - model_out)) / \ tf.cast(bs, tf.float32) else: loss = 1e4 * tf.reduce_sum(tf.abs(y - model_out) * tf.expand_dims(x_w, axis=-1)) / \ tf.reduce_sum(x_w) optimizer = tf.train.AdamOptimizer(learning_rate) grad_update = optimizer.minimize(loss) if args.arch == 'cnn': saliency = tf.gradients(-loss, x) else: used_model_out = model_out * tf.expand_dims(x_w, axis=-1) saliency = tf.gradients(used_model_out, x) if args.rnn_type == 'static': rnn_states_grad = tf.gradients(used_model_out, [s.c for s in rnn_states]) saver = tf.train.Saver() init = tf.global_variables_initializer() #merged_summary = tf.summary.merge_all() #merged_summary = tf.contrib.summary.all_summary_ops() # session sess = tf.Session(config=tf.ConfigProto(log_device_placement=False)) if args.debug: sess = tf_debug.LocalCLIDebugWrapperSession(sess) #if args.tf_summary: # tf.contrib.summary.initialize(graph=sess.graph, session=sess) # train_writer = tf.summary.FileWriter(args.tf_summary_path, sess.graph) # train_writer.add_graph(sess.graph) # load model or init model if type(args.load_model_path) is str: logging.info('load model from "{}"'.format(args.load_model_path)) saver.restore(sess, args.load_model_path) else: sess.run(init) # train model epochs = args.epoch for i in range(epochs): if args.data == 'gau': batch = next_batch(args.data, batch_size, h, w, anisotropy) elif args.data == 'ir': batch = next_batch(args.data, batch_size, h, w, mean_match_query_term=mean_match_query_term, mean_match_doc_term=mean_match_doc_term, dist=distribution) st = time() batch_x = np.expand_dims(batch[0], axis=3) batch_y = np.expand_dims(batch[1], axis=3) batch_x_w = batch[2] #if args.debug: # print(batch[0][0]) # print(batch[1][0]) # print(batch[2][0]) # input() if args.arch == 'lstm' and i == 0: print( 'Shuffling the batch in the height dimension for the standard LSTM.' 'Its like having h LSTM on the width axis.') perms = np.random.permutation(list(range(w))) batch_x = batch_x[:, perms, :, :] batch_y = batch_y[:, perms, :, :] pass loss_val, _ = sess.run([loss, grad_update], feed_dict={ x: batch_x, y: batch_y, x_w: batch_x_w }) # console output if i % 50 == 0: print('epochs = {0} | loss = {1:.3f} | time {2:.3f}'.format( str(i).zfill(3), loss_val, time() - st)) #print([v[0] for v in get_variables(sess)]) #input() # save model if args.save_model_path and args.save_model_epoch > 0 and i > 0 and \ (i % args.save_model_epoch == 0 or i == epochs - 1): logging.info('save model to "{}" at epochs {}'.format( args.save_model_path, i)) saver.save(sess, args.save_model_path) # visualize model if args.visualize and i % args.visualize == 0: cnn_vis = CNNVis() if visualization == 'kernel' and args.arch == 'cnn': conv_kernels, = sess.run([tf.get_collection('conv_kernel')]) kmax = np.max([np.max(k) for k in conv_kernels]) kmin = np.min([np.min(k) for k in conv_kernels]) print('kernal max: {}, min: {}'.format(kmax, kmin)) kmax = max(abs(kmax), abs(kmin)) or 1 kmin = -kmax cnn_vis.set_max_min(kmax, kmin) for i, c in enumerate(tf.get_collection('conv_kernel')): cnn_vis.plot_conv_kernel(conv_kernels[i], c.name) input('press to continue') elif visualization == 'saliency': saliency_map, = \ sess.run(saliency, feed_dict={x: batch_x, y: batch_y, x_w: batch_x_w}) if args.arch == 'mdlstm': # erase the gradiant at the top-left corner when the corresponding input is zero saliency_mask = np.any( np.abs(batch_x[:, 0, 0, :]) > UNIFORM_NOISE, axis=1, keepdims=True).astype(np.float32) saliency_map[:, 0, 0, :] = saliency_map[:, 0, 0, :] * saliency_mask cnn_vis.plot_saliency_map(batch_x, saliency_map) if args.rnn_type == 'static': rnn_states_val = sess.run([s.h for s in rnn_states], feed_dict={ x: batch_x, y: batch_y, x_w: batch_x_w }) rnn_states_grad_val = \ sess.run(rnn_states_grad, feed_dict={x: batch_x, y: batch_y, x_w: batch_x_w}) rnn_vis = RNNVis() rnn_vis.plot_hidden_grad( np.transpose(np.stack(rnn_states_val), [1, 0, 2]), np.transpose(np.stack(rnn_states_grad_val), [1, 0, 2]), sequence=np.reshape(batch_x, [batch_size, h, w]), shape=[1, h]) # summarize model #if args.tf_summary and i % args.tf_summary == 0: # logging.info('summarize model to "{}" at epochs {}'.format(args.tf_summary_path, i)) # summary = sess.run([merged_summary], feed_dict={x: batch_x, y: batch_y, x_w: batch_x_w}) # train_writer.add_summary(summary, i) # eval model if args.eval and i % args.eval == 0: act = input('press "c" to continue') while act != 'c': batch = next_batch(args.data, 1, h, w, mean_match_query_term=mean_match_query_term, mean_match_doc_term=mean_match_doc_term, dist=distribution) model_out_val, loss_val = sess.run( [model_out, loss], feed_dict={ x: np.expand_dims(batch[0], axis=3), y: np.expand_dims(batch[1], axis=3), x_w: batch[2] }) print('matrix:') with printoptions(precision=3, suppress=True): eval_matrix = np.rint(np.abs(batch[0][0] * w)).astype(int) print(eval_matrix) print('TF: {}'.format(np.sum(eval_matrix))) if args.arch == 'cnn': print('target: {0:.3f}, output: {1:.3f}'.format( batch[1][0, h - 1, w - 1], model_out_val[0, 0])) else: print('target: {0:.3f}, output: {1:.3f}'.format( batch[1][0, h - 1, w - 1], model_out_val[0, h - 1, w - 1, 0])) print('loss: {0:.3f}'.format(loss_val)) act = input('press "c" to continue')
-2.35924799e-01, 1.78741791e+00, 1.98098145e+00, 2.45745910e+00, -1.92949099e+00, 4.40071032e-01, 1.67750682e+00, 2.29228560e+00, 1.91505982e+00, -2.21207919e+00, 1.56207029e+00, 1.21830856e+00, 7.31777196e-01, 1.89957659e+00, -1.55168259e+00, 1.53547002e+00, 2.96527969e-02, 3.32278097e-01 ]) ] ]) def use(): return model #voorbeeldje print cnn.cnn("dataset/0/img001-001.png", model, [1, 0]) lettersArray = ['0', '1'] dataSet = [] #alle labels lettersArray = ['0', '1'] #vectors voor classificatie systeem genereren AllLabels = np.zeros((len(lettersArray), len(lettersArray))) for x in xrange(len(lettersArray)): for y in xrange(len(lettersArray)): if x == y: AllLabels[x][y] = 1 #importen van data labelSet = []
def train(alpha, totalGeneration, modelfile, metadatafile): #zorgen dat data goed wordt weggeschreven with open(metadatafile, "w") as myfile: myfile.write('\n\n\n\n') #tijd en generatie bijhouden startTime = int(time.time()) vervangTekst(metadatafile, 0, "Training gestart op " + str(int(time.time())) + "..\n") #alle labels lettersArray = ['0','1'] #vectors voor classificatie systeem genereren AllLabels = np.zeros((len(lettersArray), len(lettersArray))) for x in xrange(len(lettersArray)): for y in xrange(len(lettersArray)): if x == y: AllLabels[x][y] = 1 #het maken van de startweights hiddenSize = 150 #hiddenSize zijn het aantal nodes aan het einde van de 2e hidden layer model = np.asarray([ np.asarray([[-1, 0, 2, 0, -1, 0, -1, 3, -1, 0, 2, 3, 4, 3, 2, 0, -1, 3, -1, 0, -1, 0, 2, 0, -1], [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, -5, 4, 1, 0, -1, 3, -1, 0, 0, -2, 1, -2, 0], [0, -1, 3, -1, 0, 0, -1, 3, -1, 0, 0, -1, 3, -1, 0, 0, -1, 3, -1, 0, 0, -1, 3, -1, 0], [0, 0, 0, 0, 0, -1, -1, -1, -1, -1, 3, 3, 3, 3, 3, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0], [0, -2, 1, -2, 0, 0, -1, 3, -1, 0, 1, 3, -5, 3, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0], [2, 1, -1, 1, 2, 1, 3, 1, 3, 1, -1, 1, 4, 1, -1, 1, 3, 1, 3, 1, 2, 1, -1, 1, 2]]), np.asarray([[1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 4, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 4, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 4, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 4, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 4, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 4, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1], [4, 4, 4, 4, 4, 4, 2, 2, 2, 4, 4, 2, 0, 2, 4, 4, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 4, 4, 2, 0, 2, 4, 4, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 4, 4, 2, 0, 2, 4, 4, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 4, 4, 2, 0, 2, 4, 4, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 4, 4, 2, 0, 2, 4, 4, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 4, 4, 2, 0, 2, 4, 4, 2, 2, 2, 4, 4, 4, 4, 4, 4], [0, 0, 0, 0, 0, -1, -1, 1, -1, -1, 1, 1, 2, 1, 1, -1, -1, 1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 4, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, 0, 0, -2, -2, -2, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 1, 2, 0, 1, 1, 2, 1, 1, 0, 2, 1, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 4, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 2, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 1, 2, 1, 0, 1, 2, 4, 2, 1, 0, 1, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, -1, -1, -1, 0, -1, -1, -2, -1, -1, 0, -1, -1, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, -1, 0, 0, 0, -1, -1, 0, 1, 0, -1, -1, 0, 0, 0, -1, -1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, -1, -1, 0, -1, -1, -2, -1, -1, 0, -1, -1, -1, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 2, 1, 2, 0, 1, 1, 4, 1, 1, 0, 2, 1, 2, 0, 0, 0, 1, 0, 0], [1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 4, 2, 0, 2, 4, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 3, 2, 0, 1, 3, 4, 3, 1, 0, 2, 3, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, 0, 0, -1, -2, -1, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 2, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -2, -3, -2, 0, -1, -3, -4, -3, -1, 0, -2, -3, -2, 0, 0, 0, -1, 0, 0, 0, -1, 1, 3, 4, -1, -1, 1, 2, 3, 1, 1, 1, 1, 1, 3, 2, 1, -1, -1, 4, 3, 1, -1, 0], [0, 0, 2, 0, 0, 0, 1, 2, 1, 0, 2, 2, 3, 2, 2, 0, 1, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, 0, 0, -1, -2, -1, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 3, 1, 0, 0, 1, 4, 1, 0, 0, 1, 3, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 2, 3, 4, 3, 2, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, 0, 0, -1, -2, -1, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 3, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0] ]), [np.asarray(np.random.rand((hiddenSize + 1) * len(lettersArray)))] ]) #importen van data labelSet = [] dataSet = [] for x in xrange(len(lettersArray)): y = 0 while os.path.isfile("dataset/" + lettersArray[x] + "/img" + str(x + 1).zfill(3) + "-" + str(y + 1).zfill(3) + ".png"): dataSet.append(str("dataset/" + lettersArray[x] + "/img" + str(x + 1).zfill(3) + "-" + str(y + 1).zfill(3) + ".png")) labelSet.append(int(x)) y += 1 y = 0 while os.path.isfile("dataset/" + lettersArray[x] + "/img" + str(x + 1).zfill(3) + "-" + str(y + 1).zfill(5) + ".png"): dataSet.append(str("dataset/" + lettersArray[x] + "/img" + str(x + 1).zfill(3) + "-" + str(y + 1).zfill(5) + ".png")) labelSet.append(int(x)) y += 1 dataSet = np.asarray(dataSet) #label koppelen aan data allData = [] i = 0 for data in dataSet: allData.append([data, labelSet[i]]) i += 1 #start van nieuwe generatie for numLoop in xrange(totalGeneration): #metadatafile aanpassen vervangTekst(metadatafile, 1, "Bezig met generatie " + str(numLoop) + "..\n") #willekeurige data kiezen gebruikteData = allData[random.randint(0, len(allData) - 1)] print gebruikteData[0] #neurale netwerk uitvoeren outputData = cnn.cnn(gebruikteData[0], model, AllLabels[gebruikteData[1]], True) #backpropagation for i in range(len(model[2][0])): x = i%(hiddenSize + 1) y = math.floor(i/(hiddenSize + 1)) derivitive = (outputData[2][y] - outputData[1][y]) * outputData[3][x] model[2][0][i] -= alpha * derivitive #gegevens in de documenten aanpassen with open(modelfile, "w") as myfile: myfile.write(str(model[0]) + ',\n') myfile.write(str(model[1]) + ',\n') myfile.write(str(np.asarray(model[2])) + ',\n') with open(metadatafile, "a") as myfile: myfile.write(str(numLoop) + ' ' + str(outputData[1][1]) + ' ' + str(outputData[0]) + ' ' + str(outputData[2][0]) + '\n')
-1.28151456e+00, -3.84942979e-01, 1.82922878e+00, 1.51436484e+00, 1.75569719e+00, -1.44607211e+00, 9.42831695e-01, 1.25711253e+00, 1.57347694e+00, 1.74176362e+00, -1.79957228e+00, 1.18676917e+00, 5.11967633e-01, 1.28159856e+00, 1.68257140e+00, -1.45429579e+00, 7.37992814e-01, -3.13833775e-01, -2.36384065e-01, 2.39000231e+00, -1.13071734e+00, -2.15551674e-01, 7.06773267e-01, 1.24026000e+00, 3.31196233e+00, -2.80934925e+00, -2.70676026e-01, 2.51773927e+00, 2.75172941e+00, 3.27117161e+00, -3.15860714e+00, 8.73311068e-01, 2.48942632e+00, 2.41422698e+00, 2.17283531e+00, -2.89391240e+00, 1.93921713e+00, 1.73801437e+00, 1.49028309e+00, 2.74509100e+00, -1.78934362e+00, 1.46492456e+00, -3.18648174e-01, -7.67231784e-01, 5.90848896e-01, 1.28089161e+00, -2.59931874e+00, 5.69308542e-02, 5.24040403e-01, 2.13501819e+00, -2.28464136e-01, -1.39081488e+00, 1.76397903e+00, 2.57345867e+00, 2.07920380e+00, -4.70071076e-01, -6.50439517e-01, 2.78756990e+00, 2.37350360e+00, 1.21889865e+00, 3.96533847e-02, 2.07270976e-01, 1.62793631e+00, 1.72390425e+00, -1.17826976e+00, -6.05697727e-02, 5.26893235e-01, -7.59343269e-01, -3.02901884e-01, 1.89771149e+00, -1.01298394e+00, 1.25809902e-01, 3.86857040e-01, 9.22495501e-01, 2.89913946e+00, -2.79842942e+00, -2.35924799e-01, 1.78741791e+00, 1.98098145e+00, 2.45745910e+00, -1.92949099e+00, 4.40071032e-01, 1.67750682e+00, 2.29228560e+00, 1.91505982e+00, -2.21207919e+00, 1.56207029e+00, 1.21830856e+00, 7.31777196e-01, 1.89957659e+00, -1.55168259e+00, 1.53547002e+00, 2.96527969e-02, 3.32278097e-01 ]) ] ]) imgPath = sys.argv[1] print cnn.cnn(imgPath, model, [1, 0])[0]
logger.info('Load data') ############################################################################### # Build the model ############################################################################### OPTIMIZER = {'Adam': optim.Adam, 'SGD': optim.SGD} logger.info('Build the model') if os.path.isfile(os.path.join(args.data_dir, 'model.tar.gz')): logger.info('Model exists. Reload model for continued training') tar = tarfile.open(os.path.join(args.data_dir, 'model.tar.gz')) tar.extractall(args.data_dir) tar.close() model = cnn(args.similarity_dims, 152) model.load_state_dict(torch.load(os.path.join(args.data_dir, 'model.pth'))) else: logger.info( 'No model found. Loading a new ResNet model with default pre-trained weights' ) model = cnn(args.similarity_dims, 152) optimizer = OPTIMIZER[args.optimizer](model.parameters(), lr=args.learning_rate) # Save arguments used to create model for restoring the model later with open(MODEL_INFO_PATH, 'wb') as f: model_info = {'simililarity-dims': args.similarity_dims}
if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument( '--file', type=pathlib.Path, help='Include CSV file using --file arg' ) parser.add_argument('--cnn', action='store_true') parser.add_argument('--rnn', action='store_true') parser.add_argument('--ae', action='store_true') parser.add_argument('--ffnn', action='store_true') args = parser.parse_args() if not args.file: sys.exit('Include dataset to run network using: --file <PATH>') x_train, y_train = translate.run(args.file) if args.ffnn: ffnn(x_train, y_train) elif args.rnn: rnn(x_train, y_train) elif args.cnn: cnn(x_train, y_train) elif args.ae: ae(x_train, y_train) else: sys.exit('Include network type: [--cnn, --rnn, --ae, --ffnn]')
def cnn_rnn(match_matrix, dq_size, query, query_emb, doc, doc_emb, word_vector, **kwargs): ''' Use CNN to select regions and RNN to represent ''' bs = tf.shape(match_matrix)[0] max_q_len = tf.shape(query)[1] max_d_len = tf.shape(doc)[1] thres = kwargs['threshold'] time = kwargs['time'] state_ta = kwargs['state_ta'] print('threshold: {}'.format(thres)) # use CNN to choose regions with vs.variable_scope('CNNRegionFinder'): cnn_decision_value = cnn(tf.expand_dims(match_matrix, axis=-1), architecture=[(5, 5, 1, 4), (1, 1), (1, 1, 4, 1), (1, 1)], activation='tanh') cnn_decision_value = tf.Print(cnn_decision_value, [cnn_decision_value[0, :20, :5, 0]], message='cnn', summarize=100) cnn_decision_value = tf.reshape(cnn_decision_value, tf.shape(cnn_decision_value)[:3]) # mask out the words beyond the boundary doc_mask = tf.expand_dims(tf.range(max_d_len), dim=0) < tf.reshape( dq_size[:1], [bs, 1]) query_mask = tf.expand_dims(tf.range(max_q_len), dim=0) < tf.reshape( dq_size[1:], [bs, 1]) mask = tf.cast(tf.logical_and(tf.expand_dims(doc_mask, axis=2), tf.expand_dims(query_mask, axis=1)), dtype=tf.float32) cnn_decision_value = (cnn_decision_value - thres) * mask + thres # make decision by "or" doc_decision_value = tf.reduce_max(cnn_decision_value, axis=2) query_decision_value = tf.reduce_max(cnn_decision_value, axis=1) doc_decision = doc_decision_value > thres query_decision = query_decision_value > thres # print debug doc_decision = tf.Print(doc_decision, [ tf.reduce_mean( tf.reduce_sum(tf.cast(doc_decision, tf.int32), axis=1)) ], message='avg all doc piece:') query_decision = tf.Print(query_decision, [ tf.reduce_mean( tf.reduce_sum(tf.cast(query_decision, tf.int32), axis=1)) ], message='avg all query piece:') ''' with vs.variable_scope('ThresholdRegionFinder'): # randomly mask some part to avoid very long sequence ber = tf.contrib.distributions.Bernoulli(probs=0.99) ber = ber.sample([1, tf.shape(match_matrix)[1], 1]) match_matrix *= tf.cast(ber, dtype=match_matrix.dtype) decision = tf.logical_or(match_matrix>0.4, match_matrix<-0.0) doc_decision = tf.reduce_any(decision, axis=2) doc_decision_value = tf.ones_like(doc_decision, dtype=tf.float32) #query_decision = tf.reduce_any(decision, axis=1) query_decision = tf.reduce_any(tf.logical_not(tf.equal(match_matrix, 0.0)), axis=1) # special for query query_decision_value = tf.ones_like(query_decision, dtype=tf.float32) doc_decision = tf.Print(doc_decision, [tf.reduce_mean(tf.reduce_sum(tf.cast(doc_decision, tf.float32), axis=1))], message='avg all doc piece:') query_decision = tf.Print(query_decision, [tf.reduce_mean(tf.reduce_sum(tf.cast(query_decision, tf.float32), axis=1))], message='avg all query piece:') ''' with vs.variable_scope('RNNRegionRepresenter'): doc_piece_emb, doc_piece_num = piece_rnn(doc_decision, doc_decision_value, doc, dq_size[0], word_vector, **kwargs) #doc_piece_emb, doc_piece_num = whole_rnn(doc, dq_size[0], word_vector, **kwargs) vs.get_variable_scope().reuse_variables() query_piece_emb, query_piece_num = piece_rnn(query_decision, query_decision_value, query, dq_size[1], word_vector, **kwargs) #query_piece_emb, query_piece_num = whole_rnn(query, dq_size[1], word_vector, **kwargs) with vs.variable_scope('KNRMAggregator'): # interaction match_matrix = tf.matmul(doc_piece_emb, tf.transpose(query_piece_emb, [0, 2, 1])) max_q_len = tf.shape(query_piece_emb)[1] max_d_len = tf.shape(doc_piece_emb)[1] dq_size = tf.stack([doc_piece_num, query_piece_num], axis=0) # use K-NRM if 'input_mu' in kwargs and kwargs['input_mu'] != None: input_mu = kwargs['input_mu'] else: input_mu = np.array(list(range(-10, 10 + 1, 2))) / 10 #input_mu = [1.0] number_of_bin = len(input_mu) - 1 input_sigma = [0.1] * number_of_bin + [0.1] state_ta = tf.cond( tf.greater(time, 0), lambda: state_ta, lambda: state_ta.write( 0, tf.zeros([bs, number_of_bin + 1], dtype=tf.float32))) print('mu: {}, sigma: {}'.format(input_mu, input_sigma)) mu = tf.constant(input_mu, dtype=tf.float32) sigma = tf.constant(input_sigma, dtype=tf.float32) mu = tf.reshape(mu, [1, 1, 1, number_of_bin + 1]) sigma = tf.reshape(sigma, [1, 1, 1, number_of_bin + 1]) # kernelize match_matrix = tf.expand_dims(match_matrix, axis=-1) # totally discard some part of the matrix #print('discard some part of the matrix in K-NRM') #discard_match_matrix = tf.logical_and(match_matrix>=-0.1, match_matrix<=0.5) match_matrix = tf.exp(-tf.square(match_matrix - mu) / (tf.square(sigma) * 2)) # have to use mask because the weight is masked query_mask = tf.expand_dims(tf.range(max_q_len), dim=0) < tf.reshape( dq_size[1:], [bs, 1]) doc_mask = tf.expand_dims(tf.range(max_d_len), dim=0) < tf.reshape( dq_size[:1], [bs, 1]) query_mask = tf.cast(tf.reshape(query_mask, [bs, 1, max_q_len, 1]), dtype=tf.float32) doc_mask = tf.cast(tf.reshape(doc_mask, [bs, max_d_len, 1, 1]), dtype=tf.float32) match_matrix = match_matrix * query_mask * doc_mask # totally discard some part of the matrix #match_matrix *= 1-tf.cast(discard_match_matrix, dtype=tf.float32) # sum and log representation = tf.reduce_sum(match_matrix, axis=[1, 2]) # this is for manually masking out some kernels # [-1 -0.8 -0.6 -0.4 -0.2 0. 0.2 0.4 0.6 0.8 1.] #representation *= [[0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1]] #representation = tf.log(1+representation) # log is used in K-NRM # use a MLP to model interactions between evidence of different strength #mlp_arch = [number_of_bin+1, number_of_bin+1] #print('use MLP with structure {}'.format(mlp_arch)) #representation = mlp(representation, architecture=mlp_arch, activation='relu') return state_ta, representation
from tensorflow.keras.optimizers import Adam from cnn import cnn from model_preprocessor import Preprocessor model = cnn() x_train, x_test, y_train, y_test = Preprocessor.load_data_binary(10000) # Define Deep Learning Model ''' Training phrase ''' epochs = 15 batch_size = 64 adam = Adam(lr=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) model.compile(optimizer=adam, loss='binary_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_split=0.11)
PATH_IMGS = "imnet-val/val/" FILE_FEATURES = "imnet-val/cnn-50000.p" FNAME_OFFSET = 48 #prefix of stored file names to chop off IMSIZE = (224, 224) data = dataset(FILE_FEATURES,PATH_IMGS,IMSIZE,normalize=True,fname_offt=FNAME_OFFSET) X = data.X d,n = X.shape b = 200 #hash bits M = 50 #number of permutations k = 3 L = 16 model = LSH(X=X,b=b,M=M) cnn_model = cnn.cnn("mobilenet") cap = cv2.VideoCapture(0) time.sleep(0.1) pause = False empty = np.zeros((DISPLAY_SIZE[1], DISPLAY_SIZE[0], 3), dtype=np.uint8) while(True): if not pause: # Capture frame-by-frame ret, frame = cap.read() # frame = cv2.flip(frame, 1) # frame = image_resize(frame, width = DISPLAY_SIZE) resized = cv2.resize(frame, DISPLAY_SIZE, interpolation = cv2.INTER_AREA)
task_name = "1dcnn_RMSprop_no_L2" model_name = "1dcnn" optimizer_name = "RMSprop" lr = 0.001 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") epochs = 100 logging.info("""{}: - model name: {} - optimizer: {} - learning rate: {} - device : {} - epochs: {} """.format(task_name, model_name, optimizer_name, lr, device, epochs)) if __name__ == "__main__": model = cnn.cnn() # model.initialize() # get the param to update params_to_update = [] for name, param in model.named_parameters(): param.requires_grad = True params_to_update.append(param) # optimizer optimizer = getattr(optim, optimizer_name)(params_to_update, lr=lr) # dataLoaders dataLoaders = dataLoader.get_dataLoaders() # train and test
if args.cuda: train_iter = data.Iterator(train, batch_size=args.batch_size, device=torch.device('cuda', args.gpu), train=True, repeat=False, sort=False, shuffle=True, sort_within_batch=False) dev_iter = data.Iterator(dev, batch_size=args.batch_size, device=torch.device('cuda', args.gpu), train=False, repeat=False, sort=False, shuffle=False, sort_within_batch=False) else: train_iter = data.Iterator(train, batch_size=args.batch_size, train=True, repeat=False, sort=False, shuffle=True, sort_within_batch=False) dev_iter = data.Iterator(dev, batch_size=args.batch_size, train=False, repeat=False, sort=False, shuffle=False, sort_within_batch=False) config = args config.words_num = len(TEXT.vocab) config.label = args.embed_dim config.words_dim = words_dim model = cnn(config) model.embed.weight.data.copy_(TEXT.vocab.vectors) args.cuda = 0 if args.cuda: modle = model.to(torch.device("cuda:{}".format(args.gpu))) print("Shift model to GPU") # Embedding for MID predicates_emb = predicates_emb.cuda() total_num = len(dev) print(config) print("VOCAB num",len(TEXT.vocab)) print("Train instance", len(train)) print("Dev instance", total_num)
findRadius(rot_img, rot_empty) return radii[maxR] """ import size_classification import cv2 model = load_model('model_backup.h5') weights = model.get_weights() size = 150 W = 2 * size H = 2 * size my_cnn = cnn.cnn(img_width=W, img_height=H) my_cnn.set_weights(weights) img1 = cv2.imread('data_cinta/good__02/nuez0_000050.png') img2 = cv2.imread('test/data/nuez6_000000.png') img = np.concatenate((img1, img2), axis=1) img = cv2.resize(img, (4 * size, 2 * size)) pred = my_cnn.predict_classes(img.reshape([-1, 300, 600, 3]), batch_size=1) print(pred) exit(1111) empty1 = cv2.imread('data_cinta/empty/empty0.png') empty2 = cv2.imread('test/data/empty6.png') print("start") size1 = findRadius(img1, empty1) print("start")
lengthsequence = x_train.shape[1] sizevocab = len(vocabprocess.vocabulary_) epoch = 50 # # learning_rate = 0.001 batch_size = 32 num_class = y_train.shape[1] # print(vocabulary) print(num_class) logdir = "./logs/nn_logs" with tf.Session() as sess: model = cnn(sizevocab, lengthsequence, num_class, batch_size) init_op = tf.compat.v1.global_variables_initializer() sess.run(init_op) saver = tf.compat.v1.train.Saver(tf.global_variables()) # tf.summary.text("text", b) # tf.summary.histogram("weights", weight) tf.summary.histogram("fc1", model.fc) # tf.summary.histogram("fc2", model.fc3) # tf.summary.histogram("fc3", model.fc3) tf.summary.scalar("accuracy", model.accuracy) tf.summary.scalar("loss", model.loss) merge = tf.summary.merge_all()