def __init__(self, is_training=True): self.graph = tf.Graph() with self.graph.as_default(): if is_training: # self.X = tf.placeholder(tf.float32, shape=(None, 28, 28, 1)) # self.labels = tf.placeholder(tf.int64, shape=(None,)) self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads, train_mode='train', graph=self.graph) self.valX, self.vallabels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads, train_mode='test', graph=self.graph) self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32) self.build_arch() self.loss() self._summary() # t_vars = tf.trainable_variables() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) # var_list=t_vars) # self.step_op = self.global_step.assign_add(1) # self.init_op = tf.global_variables_initializer() else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.labels = tf.placeholder(tf.int32, shape=(cfg.batch_size,)) self.Y = tf.reshape(self.labels, shape=(cfg.batch_size, 10, 1)) self.build_arch() tf.logging.info('Setting up the main structure')
def predict(self, x_test, y_test, model_path): """ Use to predict batch data so as to get predicted results :param x_test: the test images :param y_test: the test masks :param model_path: the path stores trained model :return: predictions (uint8) """ tf.reset_default_graph() with tf.compat.v1.Session() as sess: saver = tf.compat.v1.train.import_meta_graph(model_path + ".meta") saver.restore(sess, model_path) graph = tf.compat.v1.get_default_graph() x = graph.get_operation_by_name("x_input").outputs[0] y = tf.compat.v1.get_collection("network_architecture")[0] no_samples = x_test.shape[0] predictions = [] n_iteration = no_samples // self.batch_size for step in range(n_iteration): x_batch, y_batch = get_batch_data(x_test, y_test, iter_step=step, batch_size=self.batch_size) preds = sess.run(y, feed_dict={x: x_batch}) predictions.append(preds) return predictions
def __init__(self, is_training=True): self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.labels = get_batch_data() self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32) self.build_arch() self.loss() self._summary() # t_vars = tf.trainable_variables() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) # var_list=t_vars) elif cfg.mask_with_y: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.Y = tf.placeholder(tf.float32, shape=(cfg.batch_size, 10, 1)) self.build_arch() else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.build_arch() tf.logging.info('Seting up the main structure')
def __init__(self, batch_size, use_recons_loss, recon_with_y): self.graph = tf.Graph() # param self.batch_size = batch_size self.use_recons_loss = use_recons_loss self.recon_with_y = recon_with_y self.x, self.labels = None, None self.caps_digit, self.v_length, self.prediction, self.batch_accuracy = None, None, None, None self.recons_input, self.decoded = None, None self.margin_loss, self.total_loss = None, None self.train_op = None with self.graph.as_default(): # input self.x, self.labels = get_batch_data(batch_size) # network: result + reconstruction self.caps_digit, self.v_length, self.prediction, self.batch_accuracy, self.recons_input, self.decoded = self.caps_net( ) # loss self.margin_loss, _, self.total_loss = self.loss_total( self.x, self.labels, self.v_length, self.decoded) # train self.train_op = self._train_op(self.use_recons_loss, self.margin_loss, self.total_loss) pass
def __init__(self, is_training=True, height=28, width=28, channels=1, num_label=10): """ Args: height: Integer, the height of inputs. width: Integer, the width of inputs. channels: Integer, the channels of inputs. num_label: Integer, the category number. """ self.height = height self.width = width self.channels = channels self.num_label = num_label self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads) self.Y = tf.one_hot(self.labels, depth=self.num_label, axis=1, dtype=tf.float32) self.build_arch() self.loss() self._summary() # t_vars = tf.trainable_variables() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, self.height, self.width, self.channels)) self.labels = tf.placeholder(tf.int32, shape=(cfg.batch_size, )) self.Y = tf.reshape(self.labels, shape=(cfg.batch_size, self.num_label, 1)) self.build_arch() tf.logging.info('Seting up the main structure')
def __init__(self, is_train=True): #tf.reset_default_graph() self.graph = tf.Graph() with self.graph.as_default(): if is_train: self.x, self.labels = get_batch_data() self.y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32) self.model_builder() self.loss() self._summary() self.tmp = tf.Variable(0, name='tmp', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize(self.final_loss, global_step=self.tmp) elif cfg.mask_with_y: self.x = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.y = tf.placeholder(tf.float32, shape=(cfg.batch_size, 10, 1)) self.model_builder() else: self.x = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.model_builder()
def __init__(self, is_training=True): self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads) self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32) self.build_arch() self.loss() self._summary() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize( self.total_loss, global_step=self.global_step) else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.labels = tf.placeholder(tf.int32, shape=(cfg.batch_size, )) self.Y = tf.reshape(self.labels, shape=(cfg.batch_size, 10, 1)) self.build_arch() tf.logging.info('Setting up the main structure')
def __init__(self, is_training=True): self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.Y = get_batch_data() self.build_arch() self.loss() self.global_step = tf.Variable(0, name='global_step', trainable=False) learning_rate = tf.train.exponential_decay(cfg.learning_rate, self.global_step, cfg.step_size, cfg.learning_rate_decay, staircase=True) tf.summary.scalar('learning rate', learning_rate) # set up adam optimizer with default setting self._optimizer = tf.train.AdamOptimizer(learning_rate) gradidents = self._optimizer.compute_gradients(self.total_loss) self.train_op = self._optimizer.apply_gradients(gradidents, global_step=self.global_step) else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.build_arch() tf.logging.info('Seting up the main structure')
def __init__(self, is_training=True): self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.labels = get_batch_data() self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32) self.build_arch() self.loss() self._summary() # t_vars = tf.trainable_variables() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize( self.total_loss, global_step=self.global_step) # var_list=t_vars) elif cfg.mask_with_y: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 150, 150, 3)) self.Y = tf.placeholder(tf.float32, shape=(cfg.batch_size, 10, 1)) self.build_arch() else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 150, 150, 3)) self.build_arch() tf.logging.info('Seting up the main structure')
def __init__(self, is_training=True, height=28, width=28, channels=1, num_label=10): """ :param is_training: boolean, 训练还是测试 :param height: Integer, the height of inputs. :param width: Integer, the width of inputs. :param channels: Integer, the channels of inputs. :param num_label: Integer, the category number. """ self.height = height self.width = width self.channels = channels self.num_label = num_label self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.labels = get_batch_data( cfg.dataset, cfg.batch_size, cfg.num_threads, train_data_number=cfg.train_data_number, validation_data_number=cfg.validation_data_number, test_data_number=cfg.test_data_number) self.Y = tf.one_hot(self.labels, depth=self.num_label, axis=1, dtype=tf.float32) self.build_arch() self.loss() self._summary() # t_vars = tf.trainable_variables() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize( self.total_loss, global_step=self.global_step) else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, self.height, self.width, self.channels)) self.labels = tf.placeholder(tf.int32, shape=(cfg.batch_size, )) self.Y = tf.reshape(self.labels, shape=(cfg.batch_size, self.num_label, 1)) self.build_arch() tf.logging.info("Setting up {} network structure".format( 'train' if is_training else 'test'))
def evaluation(): num_te_batch = 500 // cfg.batch_size fd_test_acc = save_to() with tf.Session() as sess: saver = tf.train.import_meta_graph(cfg.logdir + '/model_epoch_0001_step_4719.meta') saver.restore(sess, cfg.logdir + '/model_epoch_0001_step_4719') graph = tf.get_default_graph() for ii in graph.get_collection(name=tf.GraphKeys.QUEUE_RUNNERS): print(ii) print(len(graph.get_collection(name=tf.GraphKeys.QUEUE_RUNNERS))) teX, teY = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads, train_mode='test', graph=sess.graph) tf.logging.info('Model restored!') sess.run(tf.local_variables_initializer()) # sess.run(tf.global_variables_initializer()) test_acc = 0 coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord, sess=sess, start=True) for i in tqdm(range(num_te_batch), ncols=70, leave=False, unit='b'): # print(tf.train.latest_checkpoint('./')) X = graph.get_tensor_by_name('shuffle_batch:0') labels = graph.get_tensor_by_name('shuffle_batch:1') print(len(threads)) accuracy = graph.get_tensor_by_name('acc:0') tteX, tteY = sess.run([teX, teY]) print(len(threads)) acc = sess.run(accuracy, {X: tteX, labels: tteY}) test_acc += acc test_acc = test_acc / num_te_batch fd_test_acc.write(str(test_acc)) fd_test_acc.close() print('Test accuracy has been saved to ' + cfg.results + '/test_acc.csv') coord.request_stop() print(len(threads)) # for th in threads: # print(th, '\n') coord.join(threads)
def train_recon(sess, update, loss, idx_list, raw, model): recon_loss = 0.0 total_batch = len(idx_list) // args.batch_size for batch_idx in range(total_batch + 1): batch_idx_list = utils.get_batch_data([idx_list], batch_idx, args.batch_size)[0] if len(batch_idx_list) == 0: continue _, tmp_loss = sess.run( [update, loss], feed_dict={model.input: raw[batch_idx_list, :]}) recon_loss += tmp_loss recon_loss = recon_loss / total_batch return recon_loss
def __init__(self, is_training=True): if is_training: self.X, self.Y = get_batch_data() self.build_arch() self.loss() t_vars = tf.trainable_variables() self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize(self.total_loss, var_list=t_vars) else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) tf.logging.info('Seting up the main structure')
def train(input_train_x, input_train_y, input_dim, input_aspect, hidden_size, batch_size, embedding_dim, word_embeddings, num_layers, is_shuffle=True): print("Ready to train") # AF_LSTM af_lstm = AF_LSTM(input_dim, hidden_size, batch_size, embedding_dim, word_embeddings, num_layers, is_shuffle=True, bias=True) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(af_lstm.parameters(), lr=0.001, momentum=0.9) running_loss = 0.0 for i in range(n_iter): for x, y, s in get_batch_data(input_train_x, input_train_y, input_aspect, batch_size, n_iter=n_iter, is_shuffle=is_shuffle): # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = af_lstm(x, s) loss = criterion(outputs, y) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % 50 == 0: print('[%d, %5d] loss: %.3f' % (i + 1, i + 1, running_loss / 50)) running_loss = 0.0
def get_val_loss(net, loss_fn, valid, seq_len, chunk_size): losses = [] net.eval() hidden = net.init_hidden(chunk_size) cum_loss = 0 cum_tgt_words = 0 for i in range(0, valid.shape[0] - 1, seq_len): input_val, label = get_batch_data(valid, i, seq_len) predictions, hidden = net(to_variable(input_val), hidden) # Feed forward loss = loss_fn( predictions, to_variable(label).contiguous().view(-1)).sum() # Compute losses losses.append(loss.data.cpu().numpy()) hidden = detach_hidden_state(hidden) cum_loss += loss.data.cpu().numpy() tgt_word_num_to_predict = label.size(0) * label.size(1) cum_tgt_words += tgt_word_num_to_predict return np.asscalar(np.mean(losses)), math.exp(cum_loss / cum_tgt_words)
def train_local(sess, update, loss, c_list, n_list, y_list, raw, model): local_loss = 0.0 total_batch = len(c_list) // args.batch_size for batch_idx in range(total_batch + 1): batch_c_list, batch_n_list, batch_y_list = utils.get_batch_data( [c_list, n_list, y_list], batch_idx, args.batch_size) if len(batch_c_list) == 0: continue _, tmp_loss = sess.run( [update, loss], feed_dict={ model.m_input: raw[batch_c_list, :], model.n_input: raw[batch_n_list, :], model.y_handle: batch_y_list }) local_loss += tmp_loss local_loss = local_loss / total_batch return local_loss
def __init__(self, is_training=True): self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.Y = get_batch_data() self.build_arch() self.loss() # t_vars = tf.trainable_variables() self.optimizer = tf.train.AdamOptimizer() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) # var_list=t_vars) else: self.X = tf.placeholder(tf.float32, shape=(cfg.batch_size, 28, 28, 1)) self.build_arch() tf.logging.info('Seting up the main structure')
def __init__(self, is_training=True): self.graph = tf.Graph() with self.graph.as_default(): if not cfg.use_multimnist: self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads) self.Y = tf.one_hot(self.labels, depth=10, axis=1, dtype=tf.float32) else: self.X, self.labels = get_batch_data_multimnist(cfg.batch_size, cfg.num_threads) self.Y = tf.cast(self.labels, dtype=tf.float32) self.keep_prob = tf.placeholder_with_default(1.0, shape=(), name='keep_prob') self.build_arch() self.loss() self._summary() # t_vars = tf.trainable_variables() self.global_step = tf.Variable(0, name='global_step', trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize(self.total_loss, global_step=self.global_step) # var_list=t_vars) tf.logging.info('Seting up the main structure')
def train_attr_struc(sess, data_type): attr_struc_loss = 0.0 a_list = [] s_list = [] y_list = [] if data_type == 'user': update = uas_update loss = uas_loss cache = user_user_cache deg_table = user_u_deg attr_raw = user_attr_raw struc_raw = user_struc_raw attr_model = model.user_attr struc_model = model.user_struc adr = model.uadr sdr = model.usdr y_handle = model.uy_handle else: # item data type update = ias_update loss = ias_loss cache = item_item_cache deg_table = item_i_deg attr_raw = item_attr_raw struc_raw = item_struc_raw attr_model = model.item_attr struc_model = model.item_struc adr = model.iadr sdr = model.isdr y_handle = model.iy_handle attr_dr2, struc_dr2 = sess.run([adr, sdr], feed_dict={ attr_model.input: attr_raw, struc_model.input: struc_raw }) struc_index = nmslib.init(method='hnsw', space='negdotprod') struc_index.addDataPointBatch(struc_dr2) struc_index.createIndex({'post': 2}, print_progress=False) attr_struc_neighbours = struc_index.knnQueryBatch(attr_dr2, k=args.samp_num, num_threads=4) for node_id, struc_neigh in enumerate(attr_struc_neighbours): # pos_set = cache[node_id] | set(struc_neigh[0]) pos_set = set(struc_neigh[0]) | set([node_id]) pos_num = len(pos_set) candidate_set = set(deg_table[np.random.randint(args.table_size, size=3 * pos_num)]) neg_list = list(candidate_set - pos_set) if len(neg_list) < pos_num: continue a_list.extend([node_id] * 2 * pos_num) s_list.extend(list(pos_set)) s_list.extend(neg_list[:pos_num]) y_list.extend([1] * pos_num) y_list.extend([0] * pos_num) attr_index = nmslib.init(method='hnsw', space='negdotprod') attr_index.addDataPointBatch(attr_dr2) attr_index.createIndex({'post': 2}, print_progress=False) struc_attr_neighbours = attr_index.knnQueryBatch(struc_dr2, k=args.samp_num, num_threads=4) for node_id, attr_neigh in enumerate(struc_attr_neighbours): # pos_set = cache[node_id] | set(attr_neigh[0]) pos_set = set(attr_neigh[0]) | set([node_id]) pos_num = len(pos_set) candidate_set = set(deg_table[np.random.randint(args.table_size, size=3 * pos_num)]) neg_list = list(candidate_set - pos_set) if len(neg_list) < pos_num: continue s_list.extend([node_id] * 2 * pos_num) a_list.extend(list(pos_set)) a_list.extend(neg_list[:pos_num]) y_list.extend([1] * pos_num) y_list.extend([0] * pos_num) rand_seed = random.randint(0, 10000000) random.seed(rand_seed) random.shuffle(a_list) random.seed(rand_seed) random.shuffle(s_list) random.seed(rand_seed) random.shuffle(y_list) total_batch = len(a_list) // args.batch_size for batch_idx in range(total_batch + 1): batch_a_list, batch_s_list, batch_y_list = utils.get_batch_data( [a_list, s_list, y_list], batch_idx, args.batch_size) if len(batch_a_list) == 0: continue _, tmp_loss = sess.run( [update, loss], feed_dict={ attr_model.input: attr_raw[batch_a_list, :], struc_model.input: struc_raw[batch_s_list, :], y_handle: batch_y_list }) attr_struc_loss += tmp_loss attr_struc_loss = attr_struc_loss / total_batch return attr_struc_loss
def train(args): def degrees_normalization(node_degree): norm = sum([ math.pow(node_degree[i], args.power) for i in range(len(node_degree)) ]) sampling_table = np.zeros(int(args.table_size), dtype=np.uint32) p = 0 i = 0 for j in range(len(node_degree)): p += float(math.pow(node_degree[j], args.power)) / norm while i < args.table_size and float(i) / args.table_size < p: sampling_table[i] = j i += 1 return sampling_table logger = logging.getLogger('mylogger') logger.setLevel(logging.DEBUG) fh = logging.FileHandler('{}.log'.format(args.dataset), mode='w') fh.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) logger.addHandler(fh) user_n2i, user_i2n = read_node_id( os.path.join('../data', args.dataset, 'user_id.tsv')) item_n2i, item_i2n = read_node_id( os.path.join('../data', args.dataset, 'item_id.tsv')) adj_user_n2i, adj_user_i2n = read_node_id( os.path.join('../data', args.dataset, 'adjlist_user_id.tsv')) adj_item_n2i, adj_item_i2n = read_node_id( os.path.join('../data', args.dataset, 'adjlist_item_id.tsv')) user_list = [i for i in range(len(user_n2i))] item_list = [i for i in range(len(item_n2i))] with open(os.path.join('../data', args.dataset, 'user_attr.pkl'), 'rb') as f: user_attr_raw = pickle.load(f) with open(os.path.join('../data', args.dataset, 'item_attr.pkl'), 'rb') as f: item_attr_raw = pickle.load(f) struc_raw = {} with open(os.path.join('../data', args.dataset, 'emb_{}.txt'.format(args.dataset)), 'r', encoding='utf-8') as f: line = f.readline( ) # header line 1 (skip this header line): node_num, emb_dim line = f.readline( ) # header line 2 (skip this header line): </s>(invalid token) embedding while True: line = f.readline() if not line: break line = line.strip().split() node_id = int(line[0]) # adjlist.txt node id emb = np.array([float(v) for v in line[1:]]) struc_raw[node_id] = emb user_struc_raw = [] for user_id in range(len(user_n2i)): user_struc_raw.append(struc_raw[user_id]) item_struc_raw = [] for item_id in range(len(user_n2i), len(user_n2i) + len(item_n2i)): item_struc_raw.append(struc_raw[item_id]) user_struc_raw = np.array(user_struc_raw) item_struc_raw = np.array(item_struc_raw) del struc_raw with open(os.path.join('../data', args.dataset, 'adjlist.txt'), 'r', encoding='utf-8') as f: user_adjlist_dict = {} item_adjlist_dict = {} while True: line = f.readline() if not line: break line = line.strip().split() if int(line[0]) < len(user_n2i): user_id = int(line[0]) user_adjlist_dict[user_id] = set( [item_n2i[adj_item_i2n[int(i)]] for i in line[1:]]) else: item_id = item_n2i[adj_item_i2n[int(line[0])]] item_adjlist_dict[item_id] = set([int(i) for i in line[1:]]) with open(os.path.join('../data', args.dataset, 'train.csv'), 'r', encoding='utf-8') as f: user_pos_train = {} item_pos_train = {} while True: line = f.readline() if not line: break line = line.strip().split(',') user_pos_train.setdefault(int(line[0]), set()).add(int(line[1])) item_pos_train.setdefault(int(line[1]), set()).add(int(line[0])) with open(os.path.join('../data', args.dataset, 'valid.tsv'), 'r', encoding='utf-8') as f: u_list_valid = [] i_list_valid = [] y_list_valid = [] while True: line = f.readline() if not line: break line = line.strip().split('\t') u_list_valid.append(int(line[0])) i_list_valid.append(int(line[1])) y_list_valid.append(float(line[2])) logger.info('DATA LOADING DONE') user_user_cache = [] item_item_cache = [] user_i_deg = [] item_u_deg = [] user_u_deg = [] item_i_deg = [] for user_id in user_list: user_i_deg.append(len(user_adjlist_dict[user_id])) tmp_user_cache = set() for item_id in user_adjlist_dict[user_id]: tmp_user_cache = tmp_user_cache | item_adjlist_dict[item_id] user_user_cache.append(tmp_user_cache) user_u_deg.append(len(tmp_user_cache)) for item_id in item_list: item_u_deg.append(len(item_adjlist_dict[item_id])) tmp_item_cache = set() for user_id in item_adjlist_dict[item_id]: tmp_item_cache = tmp_item_cache | user_adjlist_dict[user_id] item_item_cache.append(tmp_item_cache) item_i_deg.append(len(item_item_cache[item_id])) user_i_deg = degrees_normalization(np.array(user_i_deg)) item_u_deg = degrees_normalization(np.array(item_u_deg)) user_u_deg = degrees_normalization(np.array(user_u_deg)) item_i_deg = degrees_normalization(np.array(item_i_deg)) del user_adjlist_dict del item_adjlist_dict logger.info('INTRA-PARTITION NETWORK SYNTHESIZED') if args.dataset == 'ami': dim_list = [[args.attr_dim_0_u, args.attr_dim_1, args.attr_dim_2], [args.struc_dim_0, args.struc_dim_1, args.struc_dim_2], [args.attr_dim_0_v, args.attr_dim_1, args.attr_dim_2], [args.struc_dim_0, args.struc_dim_1, args.struc_dim_2]] model = jointmodel.JointModelAmi(dim_list, None) elif args.dataset == 'mvl': dim_list = [[ args.attr_dim_0_u, args.attr_dim_1, args.attr_dim_2, args.attr_dim_3 ], [ args.struc_dim_0, args.struc_dim_1, args.struc_dim_2, args.struc_dim_3 ], [ args.attr_dim_0_v, args.attr_dim_1, args.attr_dim_2, args.attr_dim_3 ], [ args.struc_dim_0, args.struc_dim_1, args.struc_dim_2, args.struc_dim_3 ]] model = jointmodel.JointModelMvl(dim_list, None) else: sys.exit(1) ua_recon_loss = tf.reduce_mean([ args.lambda_0 * model.user_attr.recon_loss, args.lambda_11 * model.user_attr.en_l2_loss, args.lambda_11 * model.user_attr.de_l2_loss ]) ua_recon_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize( ua_recon_loss, var_list=model.user_attr.vars_en + model.user_attr.vars_de) us_recon_loss = tf.reduce_mean([ args.lambda_1 * model.user_struc.recon_loss, args.lambda_11 * model.user_struc.en_l2_loss, args.lambda_11 * model.user_struc.de_l2_loss, ]) us_recon_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize( us_recon_loss, var_list=model.user_struc.vars_en + model.user_struc.vars_de) ia_recon_loss = tf.reduce_mean([ args.lambda_2 * model.item_attr.recon_loss, args.lambda_11 * model.item_attr.en_l2_loss, args.lambda_11 * model.item_attr.de_l2_loss ]) ia_recon_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize( ia_recon_loss, var_list=model.item_attr.vars_en + model.item_attr.vars_de) is_recon_loss = tf.reduce_mean([ args.lambda_3 * model.item_struc.recon_loss, args.lambda_11 * model.item_struc.en_l2_loss, args.lambda_11 * model.item_struc.de_l2_loss ]) is_recon_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize( is_recon_loss, var_list=model.item_struc.vars_en + model.item_struc.vars_de) ua_local_loss = tf.reduce_mean([ args.lambda_4 * model.user_attr.local_loss, args.lambda_11 * model.user_attr.en_l2_loss, ]) ua_local_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize(ua_local_loss, var_list=model.user_attr.vars_en) us_local_loss = tf.reduce_mean([ args.lambda_5 * model.user_struc.local_loss, args.lambda_11 * model.user_struc.en_l2_loss ]) us_local_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize( us_local_loss, var_list=model.user_struc.vars_en) uas_loss = tf.reduce_mean([ args.lambda_6 * model.uas_loss, args.lambda_11 * model.user_attr.en_l2_loss, args.lambda_11 * model.user_attr.dr_l2_loss, args.lambda_11 * model.user_struc.en_l2_loss, args.lambda_11 * model.user_struc.dr_l2_loss ]) uas_update = tf.train.AdamOptimizer(learning_rate=args.intra_lr).minimize(uas_loss, var_list=model.user_attr.vars_en+model.user_attr.vars_dr+\ model.user_struc.vars_en+model.user_struc.vars_dr) ia_local_loss = tf.reduce_mean([ args.lambda_7 * model.item_attr.local_loss, args.lambda_11 * model.item_attr.en_l2_loss, ]) ia_local_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize(ia_local_loss, var_list=model.item_attr.vars_en) is_local_loss = tf.reduce_mean([ args.lambda_8 * model.item_struc.local_loss, args.lambda_11 * model.item_struc.en_l2_loss ]) is_local_update = tf.train.AdamOptimizer( learning_rate=args.intra_lr).minimize( is_local_loss, var_list=model.item_struc.vars_en) ias_loss = tf.reduce_mean([ args.lambda_9 * model.ias_loss, args.lambda_11 * model.item_attr.en_l2_loss, args.lambda_11 * model.item_attr.dr_l2_loss, args.lambda_11 * model.item_struc.en_l2_loss, args.lambda_11 * model.item_struc.dr_l2_loss ]) ias_update = tf.train.AdamOptimizer(learning_rate=args.intra_lr).minimize(ias_loss, var_list=model.item_attr.vars_en+model.item_attr.vars_dr+\ model.item_struc.vars_en+model.item_struc.vars_dr) global_loss = tf.reduce_mean([ args.lambda_10 * model.pred_loss, args.lambda_11 * model.user_attr.en_l2_loss, args.lambda_11 * model.user_struc.en_l2_loss, args.lambda_11 * model.item_attr.en_l2_loss, args.lambda_11 * model.item_struc.en_l2_loss ]) global_update = tf.train.AdamOptimizer(learning_rate=args.lr).minimize(global_loss, var_list=model.user_attr.vars_en+\ model.user_struc.vars_en+\ model.item_attr.vars_en+\ model.item_struc.vars_en) # INTER-PARTITION PROXIMITY def generate_candidate_train(): u_list = [] i_list = [] y_list = [] for user in user_list: pos_set = user_pos_train[user] pos_num = len(pos_set) candidate_set = set(item_u_deg[np.random.randint(args.table_size, size=3 * pos_num)]) neg_list = list(candidate_set - pos_set) if len(neg_list) < pos_num: continue u_list.extend([user] * 2 * pos_num) i_list.extend(list(pos_set)) i_list.extend(neg_list[:pos_num]) y_list.extend([1] * pos_num) y_list.extend([0] * pos_num) for item in item_list: pos_set = item_pos_train[item] pos_num = len(pos_set) candidate_set = set(user_i_deg[np.random.randint(args.table_size, size=3 * pos_num)]) neg_list = list(candidate_set - pos_set) if len(neg_list) < pos_num: continue u_list.extend(list(pos_set)) u_list.extend(neg_list[:pos_num]) i_list.extend([item] * 2 * pos_num) y_list.extend([1] * pos_num) y_list.extend([0] * pos_num) rand_seed = random.randint(0, 10000000) random.seed(rand_seed) random.shuffle(u_list) random.seed(rand_seed) random.shuffle(i_list) random.seed(rand_seed) random.shuffle(y_list) return u_list, i_list, y_list # FIRST-ORDER PROXIMITY def generate_candidate_local_train(cache, deg_table): c_list = [] n_list = [] y_list = [] for idx, pos_set in enumerate(cache): if len(pos_set) == 1: continue pos_num = len(pos_set) candidate_set = set(deg_table[np.random.randint(args.table_size, size=3 * pos_num)]) neg_list = list(candidate_set - pos_set) pos_set.remove(idx) pos_num = pos_num - 1 if len(neg_list) < pos_num: continue c_list.extend([idx] * 2 * pos_num) n_list.extend(list(pos_set)) n_list.extend(neg_list[:pos_num]) y_list.extend([1] * pos_num) y_list.extend([0] * pos_num) rand_seed = random.randint(0, 10000000) random.seed(rand_seed) random.shuffle(c_list) random.seed(rand_seed) random.shuffle(n_list) random.seed(rand_seed) random.shuffle(y_list) return c_list, n_list, y_list # RECONSTRUCTION LOSS def train_recon(sess, update, loss, idx_list, raw, model): recon_loss = 0.0 total_batch = len(idx_list) // args.batch_size for batch_idx in range(total_batch + 1): batch_idx_list = utils.get_batch_data([idx_list], batch_idx, args.batch_size)[0] if len(batch_idx_list) == 0: continue _, tmp_loss = sess.run( [update, loss], feed_dict={model.input: raw[batch_idx_list, :]}) recon_loss += tmp_loss recon_loss = recon_loss / total_batch return recon_loss # FIRST-ORDER PROXIMITY def train_local(sess, update, loss, c_list, n_list, y_list, raw, model): local_loss = 0.0 total_batch = len(c_list) // args.batch_size for batch_idx in range(total_batch + 1): batch_c_list, batch_n_list, batch_y_list = utils.get_batch_data( [c_list, n_list, y_list], batch_idx, args.batch_size) if len(batch_c_list) == 0: continue _, tmp_loss = sess.run( [update, loss], feed_dict={ model.m_input: raw[batch_c_list, :], model.n_input: raw[batch_n_list, :], model.y_handle: batch_y_list }) local_loss += tmp_loss local_loss = local_loss / total_batch return local_loss # ATTR-STRUC CORRELATION def train_attr_struc(sess, data_type): attr_struc_loss = 0.0 a_list = [] s_list = [] y_list = [] if data_type == 'user': update = uas_update loss = uas_loss cache = user_user_cache deg_table = user_u_deg attr_raw = user_attr_raw struc_raw = user_struc_raw attr_model = model.user_attr struc_model = model.user_struc adr = model.uadr sdr = model.usdr y_handle = model.uy_handle else: # item data type update = ias_update loss = ias_loss cache = item_item_cache deg_table = item_i_deg attr_raw = item_attr_raw struc_raw = item_struc_raw attr_model = model.item_attr struc_model = model.item_struc adr = model.iadr sdr = model.isdr y_handle = model.iy_handle attr_dr2, struc_dr2 = sess.run([adr, sdr], feed_dict={ attr_model.input: attr_raw, struc_model.input: struc_raw }) struc_index = nmslib.init(method='hnsw', space='negdotprod') struc_index.addDataPointBatch(struc_dr2) struc_index.createIndex({'post': 2}, print_progress=False) attr_struc_neighbours = struc_index.knnQueryBatch(attr_dr2, k=args.samp_num, num_threads=4) for node_id, struc_neigh in enumerate(attr_struc_neighbours): # pos_set = cache[node_id] | set(struc_neigh[0]) pos_set = set(struc_neigh[0]) | set([node_id]) pos_num = len(pos_set) candidate_set = set(deg_table[np.random.randint(args.table_size, size=3 * pos_num)]) neg_list = list(candidate_set - pos_set) if len(neg_list) < pos_num: continue a_list.extend([node_id] * 2 * pos_num) s_list.extend(list(pos_set)) s_list.extend(neg_list[:pos_num]) y_list.extend([1] * pos_num) y_list.extend([0] * pos_num) attr_index = nmslib.init(method='hnsw', space='negdotprod') attr_index.addDataPointBatch(attr_dr2) attr_index.createIndex({'post': 2}, print_progress=False) struc_attr_neighbours = attr_index.knnQueryBatch(struc_dr2, k=args.samp_num, num_threads=4) for node_id, attr_neigh in enumerate(struc_attr_neighbours): # pos_set = cache[node_id] | set(attr_neigh[0]) pos_set = set(attr_neigh[0]) | set([node_id]) pos_num = len(pos_set) candidate_set = set(deg_table[np.random.randint(args.table_size, size=3 * pos_num)]) neg_list = list(candidate_set - pos_set) if len(neg_list) < pos_num: continue s_list.extend([node_id] * 2 * pos_num) a_list.extend(list(pos_set)) a_list.extend(neg_list[:pos_num]) y_list.extend([1] * pos_num) y_list.extend([0] * pos_num) rand_seed = random.randint(0, 10000000) random.seed(rand_seed) random.shuffle(a_list) random.seed(rand_seed) random.shuffle(s_list) random.seed(rand_seed) random.shuffle(y_list) total_batch = len(a_list) // args.batch_size for batch_idx in range(total_batch + 1): batch_a_list, batch_s_list, batch_y_list = utils.get_batch_data( [a_list, s_list, y_list], batch_idx, args.batch_size) if len(batch_a_list) == 0: continue _, tmp_loss = sess.run( [update, loss], feed_dict={ attr_model.input: attr_raw[batch_a_list, :], struc_model.input: struc_raw[batch_s_list, :], y_handle: batch_y_list }) attr_struc_loss += tmp_loss attr_struc_loss = attr_struc_loss / total_batch return attr_struc_loss config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.global_variables_initializer()) logger.info('INITIALIZATION DONE') best_valid_loss = np.finfo(float).max for epoch in range(1, args.epochs + 1): # RECONSTRUCTION LOSS epoch_ua_recon_loss = train_recon(sess, ua_recon_update, ua_recon_loss, user_list, user_attr_raw, model.user_attr) epoch_us_recon_loss = train_recon(sess, us_recon_update, us_recon_loss, user_list, user_struc_raw, model.user_struc) epoch_ia_recon_loss = train_recon(sess, ia_recon_update, ia_recon_loss, item_list, item_attr_raw, model.item_attr) epoch_is_recon_loss = train_recon(sess, is_recon_update, is_recon_loss, item_list, item_struc_raw, model.item_struc) # FIRST-ORDER PROXIMITY user_c_list, user_n_list, user_y_list = generate_candidate_local_train( copy.deepcopy(user_user_cache), user_u_deg) epoch_ua_local_loss = train_local(sess, ua_local_update, ua_local_loss, user_c_list, user_n_list, user_y_list, user_attr_raw, model.user_attr) epoch_us_local_loss = train_local(sess, us_local_update, us_local_loss, user_c_list, user_n_list, user_y_list, user_struc_raw, model.user_struc) item_c_list, item_n_list, item_y_list = generate_candidate_local_train( copy.deepcopy(item_item_cache), item_i_deg) epoch_ia_local_loss = train_local(sess, ia_local_update, ia_local_loss, item_c_list, item_n_list, item_y_list, item_attr_raw, model.item_attr) epoch_is_local_loss = train_local(sess, is_local_update, is_local_loss, item_c_list, item_n_list, item_y_list, item_struc_raw, model.item_struc) del user_c_list, user_n_list, user_y_list, item_c_list, item_n_list, item_y_list # ATTR-STRUC CORRELATION epoch_uas_loss = train_attr_struc(sess, 'user') epoch_ias_loss = train_attr_struc(sess, 'item') # INTER-PARTITION PROXIMITY train_u_list, train_i_list, train_y_list = generate_candidate_train() total_batch = len(train_u_list) // args.batch_size train_epoch_loss = 0.0 for batch_idx in range(total_batch + 1): batch_u_list, batch_i_list, batch_y_list = utils.get_batch_data( [train_u_list, train_i_list, train_y_list], batch_idx, args.batch_size) if len(batch_u_list) == 0: continue _, tmp_loss = sess.run( [global_update, global_loss], feed_dict={ model.user_attr.input: user_attr_raw[batch_u_list, :], model.user_struc.input: user_struc_raw[batch_u_list, :], model.item_attr.input: item_attr_raw[batch_i_list, :], model.item_struc.input: item_struc_raw[batch_i_list, :], model.y_handle: batch_y_list }) train_epoch_loss += tmp_loss train_epoch_loss = train_epoch_loss / total_batch valid_epoch_loss = 0.0 total_batch = len(u_list_valid) // args.batch_size for batch_idx in range(total_batch + 1): batch_u_list, batch_i_list, batch_y_list = utils.get_batch_data( [u_list_valid, i_list_valid, y_list_valid], batch_idx, args.batch_size) if len(batch_u_list) == 0: continue tmp_loss = sess.run(global_loss, feed_dict={ model.user_attr.input: user_attr_raw[batch_u_list, :], model.user_struc.input: user_struc_raw[batch_u_list, :], model.item_attr.input: item_attr_raw[batch_i_list, :], model.item_struc.input: item_struc_raw[batch_i_list, :], model.y_handle: batch_y_list }) valid_epoch_loss += tmp_loss if valid_epoch_loss < best_valid_loss: best_valid_loss = valid_epoch_loss model.save_model(sess, '{}_best_model.pkl'.format(args.dataset)) logger.info('SAVED BEST MODEL AT EPOCH {}'.format(epoch)) model.save_model(sess, '{}_final_model.pkl'.format(args.dataset)) sess.close() logging.shutdown()
nr_classes = len(labels) batch_size = 64 epochs = 10 rate = 16000 #16000fps - 0.0625ms per frame stepsize = 64 #for spectogram reduction freq_bins = 32 frame_size = (int)((0.060 * rate) / stepsize) #30ms frame_step = (int)((0.030 * rate) / stepsize) #15ms print('Frame size: {}, frame step size: {}'.format(frame_size, frame_step)) # preprocess data training_set = TimitDataset('./data', labels, stepsize, freq_bins, frame_step, frame_size) trainloader = get_batch_data(training_set, batch_size) test_set = TimitDataset('./data', labels, stepsize, freq_bins, frame_step, frame_size, traintest='TEST') testloader = get_batch_data(test_set, batch_size) device = torch.cuda.device(0) capsnet = CapsuleNet(num_classes=nr_classes) capsnet.cuda() capsnet_optimizer = optim.Adam(capsnet.parameters()) convnet = ConvNet(num_classes = nr_classes) convnet.cuda() convnet_loss = torch.nn.MSELoss()
def main(): print("loading model...") generator = GEN(ITEM_NUM,USER_NUM,EMB_DIM,lamda = 0.0 / BATCH_SIZE,param = None,initdelta= INIT_DELTA, learning_rate = 0.001) discriminator = DIS(ITEM_NUM,USER_NUM,EMB_DIM,lamda = 0.1/BATCH_SIZE,param=None,initdelta = INIT_DELTA, learning_rate = 0.001) config = tf.ConfigProto() config.gpu_options.allow_growth=True with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) print("gen ",simple_test(sess,generator)) print("dis ",simple_test(sess,discriminator)) dis_log = open(workdir + 'dis_log.txt','w') gen_log = open(workdir + 'gen_log.txt','w') best = 0. for epoch in range(15): if epoch >= 0: for d_epoch in range(100): if d_epoch % 5 == 0: generate_for_d(sess,generator,DIS_TRAIN_FILE) train_size = ut.file_len(DIS_TRAIN_FILE) index = 1 while True: if index > train_size: break if index + BATCH_SIZE <= train_size + 1: input_user,input_item,input_label = ut.get_batch_data(DIS_TRAIN_FILE,index,BATCH_SIZE) else: input_user,input_item,input_label = ut.get_batch_data(DIS_TRAIN_FILE,index,train_size-index+1) index += BATCH_SIZE _ = sess.run(discriminator.d_updates,feed_dict={ discriminator.u:input_user,discriminator.i:input_item,discriminator.label:input_label }) for g_epoch in range(50): for u in user_pos_train: sample_lambda = 0.2 pos = user_pos_train[u] rating = sess.run(generator.all_logits,{generator.u:u}) exp_rating = np.exp(rating) prob = exp_rating / np.sum(exp_rating) pn = (1-sample_lambda) * prob pn[pos] += sample_lambda * 1.0 / len(pos) sample = np.random.choice(np.arange(ITEM_NUM), 2 * len(pos), p=pn) reward = sess.run(discriminator.reward, {discriminator.u: u, discriminator.i: sample}) reward = reward * prob[sample] / pn[sample] _ = sess.run(generator.gan_updates, {generator.u: u, generator.i: sample, generator.reward: reward}) result = simple_test(sess, generator) print("epoch ", epoch, "gen: ", result) buf = '\t'.join([str(x) for x in result]) gen_log.write(str(epoch) + '\t' + buf + '\n') gen_log.flush() p_5 = result[1] if p_5 > best: print('best: ', result) best = p_5 gen_log.close() dis_log.close()
# cfg['sess_path'] = '/Users/jiayu/PycharmProjects/NLU/run/1523829796' # cfg['batch_size'] = 50 # cfg['max_length'] = 30 # load dict with open('word2id_dict.pkl', 'rb') as f: word2id_dict = pickle.load(f) id2word_dict = {} for item in word2id_dict.items(): id2word_dict[item[1]] = item[0] if cfg['t']: train_path = "data/sentences.train" train_text = load_data(train_path) train_batch_data = get_batch_data(train_text[:cfg['text_num']], word2id_dict=word2id_dict, batch_size=cfg['batch_size'], max_length=cfg['max_length']) model = RNNmodel(vocab_len=cfg['vocab_len'], embedding_size=cfg['embedding_dim'], hidden_size=cfg['hidden_size'], sequency_length=cfg['max_length'], batch_size=cfg['batch_size'], is_add_layer=cfg['is_add_layer']) result_path = train(model=model, cfg=cfg, id2word_dict=id2word_dict, train_data=train_batch_data) if cfg['e']:
def main(_): coord_add = [[[8., 8.], [12., 8.], [16., 8.]], [[8., 12.], [12., 12.], [16., 12.]], [[8., 16.], [12., 16.], [16., 16.]]] with tf.Graph().as_default(): batch_x, batch_labels, datanum = utils.get_batch_data( is_training=False) num_batches_test = math.ceil(datanum / cfg.batch_size) #get the ceiling int output = net.build_arch(batch_x, coord_add, is_train=False) predict = tf.argmax(output, axis=1) batch_acc = net.test_accuracy(output, batch_labels) saver = tf.train.Saver() step = 0 summaries = [] summaries.append(tf.summary.scalar('accuracy', batch_acc)) summary_op = tf.summary.merge(summaries) sess = tf.Session() tf.train.start_queue_runners(sess=sess) ckpt = tf.train.get_checkpoint_state(cfg.logdir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print(ckpt.model_checkpoint_path) summary_writer = tf.summary.FileWriter(cfg.test_logdir, graph=sess.graph) for epoch in range(cfg.test_epoch): accuracy_sum = 0 for i in range(num_batches_test): y_pred, y, batch_acc_v, summary_str = sess.run( [predict, batch_labels, batch_acc, summary_op]) if i % 10 == 0: print('%d/%d batches are tested.' % (step, num_batches_test)) #print("labels:\n",batch_labels) print("Y:\n", y) print("Y_prediction:", batch_acc_v, "\n", y_pred) summary_writer.add_summary(summary_str, step) accuracy_sum += batch_acc_v step += 1 if i == 0: y_pred1 = y_pred label1 = y else: y_pred1 = np.concatenate((y_pred1, y_pred), axis=0) label1 = np.concatenate((label1, y), axis=0) #print("Label:",np.shape(label1),"\n", label1) ave_acc = accuracy_sum / num_batches_test # print("The last batch----Y:",np.shape(y),"\n", y) # print("Y_prediction:", batch_acc_v, "\n", y_pred) print(epoch, 'epoch: average accuracy is %f' % ave_acc) print(np.shape(y_pred1), ",", datanum) label1 = label1[:datanum] y_pred1 = y_pred1[:datanum] print("label:", np.shape(label1)) trade_data.out_indi_data(cfg.test_dataset, y_pred1, datalen=cfg.image_size)
def main(): print "load model..." param = cPickle.load(open(workdir + "model_dns_ori.pkl")) generator = GEN(ITEM_NUM, USER_NUM, EMB_DIM, lamda=0.0 / BATCH_SIZE, param=None, initdelta=INIT_DELTA, learning_rate=0.001) discriminator = DIS(ITEM_NUM, USER_NUM, EMB_DIM, lamda=0.1 / BATCH_SIZE, param=None, initdelta=INIT_DELTA, learning_rate=0.001) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.global_variables_initializer()) print "gen ", simple_test(sess, generator) print "dis ", simple_test(sess, discriminator) dis_log = open(workdir + 'dis_log.txt', 'w') gen_log = open(workdir + 'gen_log.txt', 'w') # minimax training best = 0. for epoch in range(300): if epoch >= 0: for d_epoch in range(100): if d_epoch % 5 == 0: generate_for_d(sess, generator, DIS_TRAIN_FILE) train_size = ut.file_len(DIS_TRAIN_FILE) index = 1 while True: if index > train_size: break if index + BATCH_SIZE <= train_size + 1: input_user, input_item, input_label = ut.get_batch_data( DIS_TRAIN_FILE, index, BATCH_SIZE) else: input_user, input_item, input_label = ut.get_batch_data( DIS_TRAIN_FILE, index, train_size - index + 1) index += BATCH_SIZE _ = sess.run(discriminator.d_updates, feed_dict={ discriminator.u: input_user, discriminator.i: input_item, discriminator.label: input_label }) # Train G for g_epoch in range(50): # 50 for u in user_pos_train: sample_lambda = 0.2 pos = user_pos_train[u] rating = sess.run(generator.all_logits, {generator.u: u}) exp_rating = np.exp(rating) prob = exp_rating / np.sum( exp_rating) # prob is generator distribution p_\theta pn = (1 - sample_lambda) * prob pn[pos] += sample_lambda * 1.0 / len(pos) # Now, pn is the Pn in importance sampling, prob is generator distribution p_\theta sample = np.random.choice(np.arange(ITEM_NUM), 2 * len(pos), p=pn) ########################################################################### # Get reward and adapt it with importance sampling ########################################################################### reward = sess.run(discriminator.reward, { discriminator.u: u, discriminator.i: sample }) reward = reward * prob[sample] / pn[sample] ########################################################################### # Update G ########################################################################### _ = sess.run( generator.gan_updates, { generator.u: u, generator.i: sample, generator.reward: reward }) result = simple_test(sess, generator) print "epoch ", epoch, "gen: ", result buf = '\t'.join([str(x) for x in result]) gen_log.write(str(epoch) + '\t' + buf + '\n') gen_log.flush() p_5 = result[4] if p_5 > best: print 'best: ', result best = p_5 generator.save_model(sess, "ml-100k/gan_generator.pkl") gen_log.close() dis_log.close()
g_optimizer = torch.optim.SGD( discriminator.parameters(), lr=0.001, momentum=0.9) for epoch in range(15): if epoch >= 0: for d_epoch in range(100): if d_epoch % 5 == 0: generate_for_d(generator, DIS_TRAIN_FILE) train_size = ut.file_len(DIS_TRAIN_FILE) index = 1 while True: if index > train_size: break if index + BATCH_SIZE <= train_size + 1: users, items, labels = ut.get_batch_data( DIS_TRAIN_FILE, index, BATCH_SIZE) else: users, items, labels = ut.get_batch_data( DIS_TRAIN_FILE, index, train_size - index + 1) loss_d = discriminator(users, items, labels) d_optimizer.zero_grad() loss_d.backward() d_optimizer.step() for g_epoch in range(50): for user in user_pos_train: sample_lambda = 0.2 pos = user_pos_train[user] rating = generator.all_logits(user)
def __init__(self, is_training = True): self.graph = tf.Graph() with self.graph.as_default(): if is_training: self.X, self.labels = get_batch_data(cfg.dataset, cfg.batch_size, cfg.num_threads) self.Y = tf.one_hot(self.labels, depth = 10, axis = 1, dtype = tf.float32) #depth = 10 for 10 classes self.build_arch() self.loss() self.summary() self.global_step = tf.Variable(0,name='global_step',trainable=False) self.optimizer = tf.train.AdamOptimizer() self.train_op = self.optimizer.minimize(self.total_loss, global_step = self.global_step) else: #Which is either Testing or Validation self.X = tf.placeholder(tf.float32, shape = (cfg.batch_size,28,28,1)) # 28 by 28 pixel and 1 channel self.labels = tf.placeholder(tf.int32, shape = (cfg.batch_size, )) self.Y = tf.reshape(self.labels, shape = (cfg.batch_size, 10, 1)) self.build_arch() tf.logging.info('Seting up the main structure') def build_arch(self): with tf.variable_scope('Conv1_layer'): # Conv1_layer: # Input [batch_size, 20, 20, 256] conv1 = tf.contrib.layers.conv2d(self.X, num_outputs=256, kernel_size=9, stride=1, padding='VALID') assert conv1.get_shape() == [cfg.batch_size, 20, 20, 256] # Primary Cap Layer # Output: [batch_size, 6, 6, 32, 8-Dim tensor] # i.e: [cfg.batch_size, 1152, 8, 1] with tf.variable_scope('PrimaryCaps_layer'): primaryCaps = CapsLayer(num_outputs=32, vec_len=8, with_routing=False, layer_type='CONV') caps1 = primaryCaps(conv1,kernel_size=9,stride=2) assert caps1.get_shape() == [cfg.batch_size,1152,8,1] with tf.variable_scope('DigitCaps_layer'): digitCaps = CapsLayer(num_outputs=10, vec_len=16,with_routing=True,layer_type='FC') self.caps2 = digitCaps(caps1) # Don't understand # REVIEW WHAT's MASKING with tf.variable_scope('Masking'): # calculate ||v_c||, then softmax(||v_c||) # [batch_size, 10, 16, 1] => [batch_size, 10, 1, 1] self.v_length = tf.sqrt(reduce_sum(tf.square(self.caps2),axis=2,keepdims=True)+epsilon) self.softmax_v = softmax(self.v_length, axis=1) assert self.softmax_v == [cfg.batch_size, 10, 1, 1] # Pick the index with the max softmax val of the 10 caps # [batch_size, 10, 1 ,1] => [batch_size] (index) self.argmax_idx = tf.to_int32(tf.argmax(self.softmax_v, axis=1)) assert self.argmax_idx.get_shape() == [cfg.batch_size, 1,1] self.argmax_idx = tf.reshape(self.argmax_idx, shape=(cfg.batch_size, )) # WHAT's MASK WITH Y if not cfg.mask_with_y: # indexing masked_v = [] for batch_size in range(cfg.batch_size): v = self.caps[batch_size][se;f.argmax_idx[batch_size], :] masked_v.append(tf.reshape(v,shape=(1,1,16,1))) self.masked_v = tf.concat(masked_v, axis=0) assert self.masked_v.get_shape() == [cfg.batch_size, 1, 16, 1] else: # MASK WITH TRUE LABEL self.masked_v = tf.multiply(tf.squeeze(self.caps2), tf.reshape(self.Y,(-1,10,1))) self.v_length = tf.sqrt(reduce_sum(tf.square(self.caps2),axis=2,keepdims=True)+epsilon) with tf.variable_scope('Decoder'):
def main(): print("loading model...") generator = GEN(ITEM_NUM, USER_NUM, EMB_DIM, lamda=0.0 / BATCH_SIZE, param=None, initdelta=INIT_DELTA, learning_rate=0.001) discriminator = DIS(ITEM_NUM, USER_NUM, EMB_DIM, lamda=0.1 / BATCH_SIZE, param=None, initdelta=INIT_DELTA, learning_rate=0.001) config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) print("gen ", simple_test(sess, generator)) print("dis ", simple_test(sess, discriminator)) dis_log = open(workdir + 'dis_log.txt', 'w') gen_log = open(workdir + 'gen_log.txt', 'w') best = 0. for epoch in range(15): if epoch >= 0: for d_epoch in range(100): if d_epoch % 5 == 0: generate_for_d(sess, generator, DIS_TRAIN_FILE) train_size = ut.file_len(DIS_TRAIN_FILE) index = 1 while True: if index > train_size: break if index + BATCH_SIZE <= train_size + 1: input_user, input_item, input_label = ut.get_batch_data( DIS_TRAIN_FILE, index, BATCH_SIZE) else: input_user, input_item, input_label = ut.get_batch_data( DIS_TRAIN_FILE, index, train_size - index + 1) index += BATCH_SIZE _ = sess.run(discriminator.d_updates, feed_dict={ discriminator.u: input_user, discriminator.i: input_item, discriminator.label: input_label }) for g_epoch in range(50): for u in user_pos_train: sample_lambda = 0.2 pos = user_pos_train[u] rating = sess.run(generator.all_logits, {generator.u: u}) exp_rating = np.exp(rating) prob = exp_rating / np.sum(exp_rating) pn = (1 - sample_lambda) * prob pn[pos] += sample_lambda * 1.0 / len(pos) sample = np.random.choice(np.arange(ITEM_NUM), 2 * len(pos), p=pn) reward = sess.run(discriminator.reward, { discriminator.u: u, discriminator.i: sample }) reward = reward * prob[sample] / pn[sample] _ = sess.run( generator.gan_updates, { generator.u: u, generator.i: sample, generator.reward: reward }) result = simple_test(sess, generator) print("epoch ", epoch, "gen: ", result) buf = '\t'.join([str(x) for x in result]) gen_log.write(str(epoch) + '\t' + buf + '\n') gen_log.flush() p_5 = result[1] if p_5 > best: print('best: ', result) best = p_5 gen_log.close() dis_log.close()
def main(): i_file_output = 0 print "load model..." generator = GEN(AUTHER_NUM, EMB_DIM, lamda=0.0 / BATCH_SIZE, param=None, initdelta=INIT_DELTA, learning_rate=FLAGS.init_lr_gen, lr_decay_step=FLAGS.lr_decay_iter_gen) discriminator = DIS(AUTHER_NUM, EMB_DIM, lamda=0.01 / BATCH_SIZE, param=None, initdelta=INIT_DELTA, learning_rate=FLAGS.init_lr_dis, lr_decay_step=FLAGS.lr_decay_iter_dis) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.global_variables_initializer()) dis_log = open(outputdir + 'dis_log.txt', 'w') gen_log = open(outputdir + 'gen_log.txt', 'w') # minimax training best_gen = 0. best_dis = 0. draw_count_D = 0 draw_count_G = 0 for epoch in range(FLAGS.epochs): #5000 if epoch >= 0: # Train D generate_for_d(sess, generator, DIS_TRAIN_FILE) train_size = ut.file_len(DIS_TRAIN_FILE) # generate file length for d_epoch in range(5): index = 1 while True: if index > train_size: break if index + BATCH_SIZE <= train_size + 1: input_auther, input_coauther_real, input_coauther_fake = ut.get_batch_data( DIS_TRAIN_FILE, index, BATCH_SIZE) else: input_auther, input_coauther_real, input_coauther_fake = ut.get_batch_data( DIS_TRAIN_FILE, index, train_size - index + 1) index += BATCH_SIZE _ = sess.run( [discriminator.d_updates, discriminator.clip_D], feed_dict={ discriminator.auther: input_auther, discriminator.co_real: input_coauther_real, discriminator.co_fake: input_coauther_fake }) result = simple_test(sess, discriminator) buf = '\t'.join([str(x) for x in result]) dis_log.write(str(epoch) + '\t' + buf + '\n') dis_log.flush() p_5 = result[2] if p_5 > best_dis: print 'best_dis: ', epoch, result best_dis = p_5 discriminator.save_model(sess, outputdir + "gan_discriminator.pkl") # Train G for g_epoch in range(1): for u in auther_pos_train: sample_lambda = 0.2 pos = list(set(auther_pos_train[u])) sample_times = 128 rating = sess.run(generator.softmax_logits, {generator.auther: [u]}) prob = np.reshape(rating, [-1]) sample = np.random.choice(np.arange(AUTHER_NUM), size=sample_times, p=prob) ########################################################################### # Get reward and adapt it with importance sampling ########################################################################### reward = sess.run( discriminator.reward, { discriminator.auther: np.tile(u, (sample_times)), discriminator.co_fake: sample }) ########################################################################### # Update G ########################################################################### _ = sess.run( generator.gan_updates, { generator.auther: np.tile(u, (sample_times)), generator.co: sample, generator.reward: reward }) result = simple_test(sess, generator) buf = '\t'.join([str(x) for x in result]) gen_log.write(str(epoch) + '\t' + buf + '\n') gen_log.flush() p_5 = result[2] if p_5 > best_gen: print 'best_gen: ', epoch, result best_gen = p_5 generator.save_model(sess, outputdir + "gan_generator.pkl") draw_count_G += 1 gen_log.close() dis_log.close()
def build_network(self): self.word2idx, word_embedding = data_helper.load_embedding(self.FLAGS.embedding_path) self.inputs, self.labels, self.train_num = utils.get_batch_data(self.FLAGS.train_data_path, self.FLAGS.batch_size, self.FLAGS.seq_length, self.word2idx) self.labels = tf.one_hot(self.labels, depth=self.FLAGS.class_num) # embedding layer with tf.variable_scope('embedding'): embedding = tf.get_variable('embedding', shape=word_embedding.shape, dtype=tf.float32, initializer=tf.constant_initializer(word_embedding), trainable=False) # [batch, 30, 300] inputs = tf.nn.embedding_lookup(embedding, self.inputs) self.origin = tf.reduce_mean(inputs, axis=1) inputs = tf.expand_dims(inputs, -1) with tf.variable_scope('conv1_layer'): # [batch, 30, 1, 300] input_conv = tf.layers.conv2d(inputs, self.FLAGS.filter_num, [self.FLAGS.filter_size, self.FLAGS.embedding_size]) # Primary Capsules layer with tf.variable_scope('PrimaryCaps_layer'): primaryCaps = CapsLayer(num_outputs=30, vec_len=10, with_routing=False, layer_type='CONV') caps1 = primaryCaps(input_conv, kernel_size=3, stride=1) # DigitCaps layer, return [batch_size, 2, vec_len, 1] with tf.variable_scope('DigitCaps_layer'): digitCaps = CapsLayer(num_outputs=self.FLAGS.class_num, vec_len=32, with_routing=True, layer_type='FC') # [batch_size, 2, 100, 1] self.caps2 = digitCaps(caps1) # Decoder structure # 1. Do masking, how: with tf.variable_scope('Masking'): # [batch_size, class_num, vec_len, 1] => [batch_size, class_num, 1, 1] self.v_length = tf.sqrt(tf.reduce_sum(tf.square(self.caps2), axis=2, keep_dims=True) + epsilon) # [batch_size, class_num, 1, 1] self.softmax_v = tf.nn.softmax(self.v_length, dim=1) # [batch_size, class_num, 1, 1] => [batch_size] (index) self.argmax_idx = tf.to_int32(tf.argmax(self.softmax_v, axis=1)) self.argmax_idx = tf.reshape(self.argmax_idx, shape=[-1]) # Method 1. if not mask_with_y: # indexing # [batch_size, class_num, 1, 1] one_hot_idx = tf.expand_dims(tf.expand_dims(tf.one_hot(self.argmax_idx, self.FLAGS.class_num), -1), -1) # [batch_size, 1, vec_len, 1] self.masked_v = tf.reduce_sum(self.caps2 * one_hot_idx, 1) # Method 2. masking with true label, default mode else: self.masked_v = tf.multiply(tf.squeeze(self.caps2, 3), tf.reshape(self.labels, (-1, self.FLAGS.class_num, 1))) # [batch_size, class_num, 1] self.v_length = tf.sqrt(tf.reduce_sum(tf.square(self.caps2), axis=2) + epsilon) # 2. Reconstructe the data with 3 FC layers # [batch_size, 2, vec_len, 1] => [batch_size, 64] => [batch_size, 300] with tf.variable_scope('Decoder'): vector_j = tf.reshape(self.masked_v, shape=(-1, self.FLAGS.class_num * 32)) fc1 = tf.contrib.layers.fully_connected(vector_j, num_outputs=256) fc2 = tf.contrib.layers.fully_connected(fc1, num_outputs=512) self.decoded = tf.contrib.layers.fully_connected(fc2, num_outputs=300, activation_fn=tf.tanh)
def main(): discriminator = DIS(FEATURE_SIZE, HIDDEN_SIZE, WEIGHT_DECAY, D_LEARNING_RATE, param=None) generator = GEN(FEATURE_SIZE, HIDDEN_SIZE, WEIGHT_DECAY, G_LEARNING_RATE, temperature=TEMPERATURE, param=None) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.initialize_all_variables()) print('start adversarial training') p_best_val = 0.0 ndcg_best_val = 0.0 for epoch in range(30): if epoch >= 0: # G generate negative for D, then train D print('Training D ...') for d_epoch in range(100): if d_epoch % 30 == 0: generate_for_d(sess, generator, DIS_TRAIN_FILE) train_size = ut.file_len(DIS_TRAIN_FILE) index = 1 while True: if index > train_size: break if index + BATCH_SIZE <= train_size + 1: input_pos, input_neg = ut.get_batch_data( DIS_TRAIN_FILE, index, BATCH_SIZE) else: input_pos, input_neg = ut.get_batch_data( DIS_TRAIN_FILE, index, train_size - index + 1) index += BATCH_SIZE pred_data = [] pred_data.extend(input_pos) pred_data.extend(input_neg) pred_data = np.asarray(pred_data) pred_data_label = [1.0] * len(input_pos) pred_data_label.extend([0.0] * len(input_neg)) pred_data_label = np.asarray(pred_data_label) _ = sess.run(discriminator.d_updates, feed_dict={ discriminator.pred_data: pred_data, discriminator.pred_data_label: pred_data_label }) # Train G print('Training G ...') for g_epoch in range(30): for query in query_pos_train.keys(): pos_list = query_pos_train[query] pos_set = set(pos_list) all_list = query_index_url[query] all_list_feature = [ query_url_feature[query][url] for url in all_list ] all_list_feature = np.asarray(all_list_feature) all_list_score = sess.run( generator.pred_score, {generator.pred_data: all_list_feature}) # softmax for all exp_rating = np.exp(all_list_score - np.max(all_list_score)) prob = exp_rating / np.sum(exp_rating) prob_IS = prob * (1.0 - LAMBDA) for i in range(len(all_list)): if all_list[i] in pos_set: prob_IS[i] += (LAMBDA / (1.0 * len(pos_list))) choose_index = np.random.choice(np.arange(len(all_list)), [5 * len(pos_list)], p=prob_IS) choose_list = np.array(all_list)[choose_index] choose_feature = [ query_url_feature[query][url] for url in choose_list ] choose_IS = np.array(prob)[choose_index] / np.array( prob_IS)[choose_index] choose_index = np.asarray(choose_index) choose_feature = np.asarray(choose_feature) choose_IS = np.asarray(choose_IS) choose_reward = sess.run( discriminator.reward, feed_dict={discriminator.pred_data: choose_feature}) _ = sess.run(generator.g_updates, feed_dict={ generator.pred_data: all_list_feature, generator.sample_index: choose_index, generator.reward: choose_reward, generator.important_sampling: choose_IS }) p_5 = precision_at_k(sess, generator, query_pos_test, query_pos_train, query_url_feature, k=5) ndcg_5 = ndcg_at_k(sess, generator, query_pos_test, query_pos_train, query_url_feature, k=5) if p_5 > p_best_val: p_best_val = p_5 ndcg_best_val = ndcg_5 generator.save_model(sess, GAN_MODEL_BEST_FILE) print("Best:", "gen p@5 ", p_5, "gen ndcg@5 ", ndcg_5) elif p_5 == p_best_val: if ndcg_5 > ndcg_best_val: ndcg_best_val = ndcg_5 generator.save_model(sess, GAN_MODEL_BEST_FILE) print("Best:", "gen p@5 ", p_5, "gen ndcg@5 ", ndcg_5) sess.close() param_best = cPickle.load(open(GAN_MODEL_BEST_FILE)) assert param_best is not None generator_best = GEN(FEATURE_SIZE, HIDDEN_SIZE, WEIGHT_DECAY, G_LEARNING_RATE, temperature=TEMPERATURE, param=param_best) sess = tf.Session(config=config) sess.run(tf.initialize_all_variables()) p_1_best = precision_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=1) p_3_best = precision_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=3) p_5_best = precision_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=5) p_10_best = precision_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=10) ndcg_1_best = ndcg_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=1) ndcg_3_best = ndcg_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=3) ndcg_5_best = ndcg_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=5) ndcg_10_best = ndcg_at_k(sess, generator_best, query_pos_test, query_pos_train, query_url_feature, k=10) map_best = MAP(sess, generator_best, query_pos_test, query_pos_train, query_url_feature) mrr_best = MRR(sess, generator_best, query_pos_test, query_pos_train, query_url_feature) print("Best ", "p@1 ", p_1_best, "p@3 ", p_3_best, "p@5 ", p_5_best, "p@10 ", p_10_best) print("Best ", "ndcg@1 ", ndcg_1_best, "ndcg@3 ", ndcg_3_best, "ndcg@5 ", ndcg_5_best, "p@10 ", ndcg_10_best) print("Best MAP ", map_best) print("Best MRR ", mrr_best)
def main(): discriminator = DIS(FEATURE_SIZE, HIDDEN_SIZE, WEIGHT_DECAY, D_LEARNING_RATE, param=None) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.initialize_all_variables()) print('start random negative sampling with log ranking discriminator') generate_uniform(DIS_TRAIN_FILE) train_size = ut.file_len(DIS_TRAIN_FILE) p_best_val = 0.0 ndcg_best_val = 0.0 for epoch in range(200): index = 1 while True: if index > train_size: break if index + BATCH_SIZE <= train_size + 1: input_pos, input_neg = ut.get_batch_data( DIS_TRAIN_FILE, index, BATCH_SIZE) else: input_pos, input_neg = ut.get_batch_data( DIS_TRAIN_FILE, index, train_size - index + 1) index += BATCH_SIZE pred_data = [] pred_data.extend(input_pos) pred_data.extend(input_neg) pred_data = np.asarray(pred_data) pred_data_label = [1.0] * len(input_pos) pred_data_label.extend([0.0] * len(input_neg)) pred_data_label = np.asarray(pred_data_label) _ = sess.run(discriminator.d_updates, feed_dict={ discriminator.pred_data: pred_data, discriminator.pred_data_label: pred_data_label }) p_5 = precision_at_k(sess, discriminator, query_pos_test, query_pos_train, query_url_feature, k=5) ndcg_5 = ndcg_at_k(sess, discriminator, query_pos_test, query_pos_train, query_url_feature, k=5) if p_5 > p_best_val: p_best_val = p_5 discriminator.save_model(sess, MLE_MODEL_BEST_FILE) print("Best: ", " p@5 ", p_5, "ndcg@5 ", ndcg_5) elif p_5 == p_best_val: if ndcg_5 > ndcg_best_val: ndcg_best_val = ndcg_5 discriminator.save_model(sess, MLE_MODEL_BEST_FILE) print("Best: ", " p@5 ", p_5, "ndcg@5 ", ndcg_5) sess.close() param_best = cPickle.load(open(MLE_MODEL_BEST_FILE)) assert param_best is not None discriminator_best = DIS(FEATURE_SIZE, HIDDEN_SIZE, WEIGHT_DECAY, D_LEARNING_RATE, param=param_best) sess = tf.Session(config=config) sess.run(tf.initialize_all_variables()) p_1_best = precision_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=1) p_3_best = precision_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=3) p_5_best = precision_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=5) p_10_best = precision_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=10) ndcg_1_best = ndcg_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=1) ndcg_3_best = ndcg_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=3) ndcg_5_best = ndcg_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=5) ndcg_10_best = ndcg_at_k(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature, k=10) map_best = MAP(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature) mrr_best = MRR(sess, discriminator_best, query_pos_test, query_pos_train, query_url_feature) print("Best ", "p@1 ", p_1_best, "p@3 ", p_3_best, "p@5 ", p_5_best, "p@10 ", p_10_best) print("Best ", "ndcg@1 ", ndcg_1_best, "ndcg@3 ", ndcg_3_best, "ndcg@5 ", ndcg_5_best, "p@10 ", ndcg_10_best) print("Best MAP ", map_best) print("Best MRR ", mrr_best)