def objective_and_grad(par_data): params, d, len_voc, rel_list = par_data[0] data = par_data[1] params = unroll_params(params, d, len_voc, rel_list) grads = init_dtrnn_grads(rel_list, d, len_voc) (rel_dict, Wv, b, L) = params error_sum = 0.0 num_nodes = 0 tree_size = 0 # compute error and gradient for each tree in minibatch # also keep track of total number of nodes in minibatch for index, tree in enumerate(data): nodes = tree.get_nodes() for node in nodes: node.vec = L[:, node.ind].reshape((d, 1)) tree.ans_vec = L[:, tree.ans_ind].reshape((d, 1)) prop.forward_prop(params, tree, d) error_sum += tree.error() tree_size += len(nodes) prop.backprop(params[:-1], tree, d, len_voc, grads) grad = roll_params(grads, rel_list) return (error_sum, grad, tree_size)
def objective_and_grad(all_params, trees_batch): params_train, d, n_classes, len_voc, rel_list = all_params # returns list of initialized zero gradients which backprop modifies # rel_Wr, Wv, Wc, b, b_c, We grads = init_dtrnn_grads(rel_list, d, n_classes, len_voc) rel_Wr_dict, Wv, Wc, b, b_c, We = params_train error_sum = 0.0 tree_size = 0 # compute error and gradient for each tree in minibatch # also keep track of total number of nodes in minibatch for idx, tree in enumerate(trees_batch): nodes = tree.get_word_nodes() for node in nodes: node.vec = We[:, node.ind].reshape((d, 1)) prop.forward_prop(params_train, tree, d, n_classes) error_sum += tree.error() tree_size += len(nodes) prop.backprop(params_train[:-1], tree, d, n_classes, len_voc, grads) return error_sum, grads, tree_size
def objective_and_grad(par_data): params, d, len_voc, rel_list = par_data[0] data = par_data[1] params = unroll_params(params, d, len_voc, rel_list) grads = init_dtrnn_grads(rel_list, d, len_voc) (rel_dict, Wv, b, L) = params error_sum = 0.0 num_nodes = 0 tree_size = 0 # compute error and gradient for each tree in minibatch # also keep track of total number of nodes in minibatch for index, tree in enumerate(data): nodes = tree.get_nodes() for node in nodes: node.vec = L[:, node.ind].reshape( (d, 1)) tree.ans_vec = L[:, tree.ans_ind].reshape( (d, 1)) prop.forward_prop(params, tree, d) error_sum += tree.error() tree_size += len(nodes) prop.backprop(params[:-1], tree, d, len_voc, grads) grad = roll_params(grads, rel_list) return (error_sum, grad, tree_size)
def objective_and_grad(par_data): params, d, c, len_voc, rel_list = par_data[0] data = par_data[1] # returns list of initialized zero gradients which backprop modifies grads = init_dtrnn_grads(rel_list, d, c, len_voc) (rel_dict, Wv, Wc, b, b_c, L) = params error_sum = 0.0 num_nodes = 0 tree_size = 0 # compute error and gradient for each tree in minibatch # also keep track of total number of nodes in minibatch for index, tree in enumerate(data): nodes = tree.get_nodes() for node in nodes: node.vec = L[:, node.ind].reshape((d, 1)) prop.forward_prop(params, tree, d, c) error_sum += tree.error() tree_size += len(nodes) prop.backprop(params[:-1], tree, d, c, len_voc, grads) return (error_sum, grads, tree_size)
def objective_and_grad(par_data): params, d, c, len_voc, rel_list = par_data[0] data = par_data[1] # returns list of initialized zero gradients which backprop modifies grads = init_dtrnn_grads(rel_list, d, c, len_voc) (rel_dict, Wv, Wc, b, b_c, L) = params error_sum = 0.0 num_nodes = 0 tree_size = 0 # compute error and gradient for each tree in minibatch # also keep track of total number of nodes in minibatch for index, tree in enumerate(data): nodes = tree.get_nodes() for node in nodes: node.vec = L[:, node.ind].reshape( (d, 1) ) prop.forward_prop(params, tree, d, c) error_sum += tree.error() tree_size += len(nodes) prop.backprop(params[:-1], tree, d, c, len_voc, grads) return (error_sum, grads, tree_size)
def evaluate(trees_test, rel_Wr_dict, Wv, Wc, b, b_c, We, c, sents_test, aspect_terms_true, correctness_file, mixed=False): d = We.shape[0] aspect_words = set() all_y_true, all_y_pred = list(), list() assert len(trees_test) == len(sents_test) correctness = list() hit_cnt, aspect_true_cnt, aspect_pred_cnt = 0, 0, 0 for ind, tree in enumerate(trees_test): nodes = tree.get_word_nodes() for index, node in enumerate(nodes): if node.ind > -1: node.vec = We[:, node.ind].reshape((d, 1)) prop.forward_prop([rel_Wr_dict, Wv, Wc, b, b_c, We], tree, d, c, labels=False) y_pred = list() for n in nodes[1:]: if n.is_word: yi_pred = n.predict_label.flatten().argmax() y_pred.append(yi_pred) cur_aspect_terms = utils.aspect_terms_from_labeled(tree, y_pred) for t in cur_aspect_terms: aspect_words.add(t) aspect_pred_cnt += len(cur_aspect_terms) cur_aspects_true = sents_test[ind].get('terms', list()) aspect_true_cnt += len(cur_aspects_true) new_hit_cnt = 0 for t in cur_aspects_true: if t['term'] in cur_aspect_terms: new_hit_cnt += 1 hit_cnt += new_hit_cnt if new_hit_cnt == len(cur_aspects_true) and new_hit_cnt == len(cur_aspect_terms): correctness.append(1) else: correctness.append(0) # if len(cur_aspect_terms) != len(cur_aspects_true) or not hit: # tree.disp() # print(y_pred) # print(cur_aspect_terms) # print(sents_test[ind]) # print() # p, r, f1 = utils.set_evaluate(aspect_terms_true, aspect_words) # print(p, r, f1) p1, r1 = hit_cnt / aspect_pred_cnt, hit_cnt / aspect_true_cnt print(p1, r1, 2 * p1 * r1 / (p1 + r1)) # for w in aspect_terms_true: # if w not in aspect_words: # print(w) with open('d:/data/aspect/semeval14/deprnn-correctness.txt', 'w', encoding='utf-8') as fout: fout.write('\n'.join([str(i) for i in correctness]))
def objective_and_grad(par_data): #params, d, len_voc, rel_list = par_data[0] params, d, c, len_voc, rel_list1, rel_list2 = par_data[0] data = par_data[1] #params = unroll_params(params, d, len_voc, rel_list) #return [rel_dict, Wv, Wc, b, b_c, We] params = unroll_params(params, d, c, len_voc, rel_list1, rel_list2) # returns list of zero gradients which backprop modifies #grads = init_dtrnn_grads(rel_list, d, len_voc) grads = init_dtrnn_grads(rel_list1, rel_list2, d, c, len_voc) #(rel_dict, Wv, b, L) = params (rel_dict1, rel_dict2, Wv_1, Wv_2, Wc, b_1, b_2, b_c, L) = params error_sum = 0.0 num_nodes = 0 tree_size = 0 # compute error and gradient for each tree in minibatch # also keep track of total number of nodes in minibatch for index, tree in enumerate(data): nodes = tree.get_nodes() for node in nodes: node.vec = L[:, node.ind].reshape((d, 1)) #tree.ans_vec = L[:, tree.ans_ind].reshape( (d, 1)) #prop.forward_prop(params, tree, d) prop.forward_prop(params, tree, d, c) error_sum += tree.error() tree_size += len(nodes) #prop.backprop(params[:-1], tree, d, len_voc, grads) prop.backprop(params[:-1], tree, d, c, len_voc, grads) grad = roll_params(grads, rel_list1, rel_list2) return (error_sum, grad, tree_size)
def objective_and_grad(par_data): #params, d, len_voc, rel_list = par_data[0] params, d, c, len_voc, rel_list1, rel_list2 = par_data[0] data = par_data[1] #params = unroll_params(params, d, len_voc, rel_list) #return [rel_dict, Wv, Wc, b, b_c, We] params = unroll_params(params, d, c, len_voc, rel_list1, rel_list2) # returns list of zero gradients which backprop modifies #grads = init_dtrnn_grads(rel_list, d, len_voc) grads = init_dtrnn_grads(rel_list1, rel_list2, d, c, len_voc) #(rel_dict, Wv, b, L) = params (rel_dict1, rel_dict2, Wv_1, Wv_2, Wc, b_1, b_2, b_c, L) = params error_sum = 0.0 num_nodes = 0 tree_size = 0 # compute error and gradient for each tree in minibatch # also keep track of total number of nodes in minibatch for index, tree in enumerate(data): nodes = tree.get_nodes() for node in nodes: node.vec = L[:, node.ind].reshape( (d, 1) ) #tree.ans_vec = L[:, tree.ans_ind].reshape( (d, 1)) #prop.forward_prop(params, tree, d) prop.forward_prop(params, tree, d, c) error_sum += tree.error() tree_size += len(nodes) #prop.backprop(params[:-1], tree, d, len_voc, grads) prop.backprop(params[:-1], tree, d, c, len_voc, grads) grad = roll_params(grads, rel_list1, rel_list2) return (error_sum, grad, tree_size)