def train_one_epoch(epoch): # We can use dropout in training? total_loss = 0. start_time = time.time() ntokens = len(corpus.dictionary) ntokens_out = len(corpus.dictionary_out) hidden_encoder = model_encoder.init_hidden(args.batch_size) hidden_pos = model_pos.init_hidden() for i in train_data: X = torch.LongTensor([x['X'] for x in i]) Y = torch.LongTensor([x['Y'] for x in i]) Y_tree = [x['Y_tree'] for x in i] if args.cuda: X = X.cuda() Y = Y.cuda() model_pos.train() model_encoder.train() model_word.train() # hidden_encoder = repackage_hidden(hidden_encoder) # hidden_pos = repackage_hidden(hidden_pos) optimizer_pos.zero_grad() optimizer_encoder.zero_grad() pos_loss, decoder_loss = batch_loss(X, Y, Y_tree) pos_loss.backward() decoder_loss.backward() if args.clip: torch.nn.utils.clip_grad_norm_(params, args.clip) optimizer_pos.step() optimizer_encoder.step() if random() > 0.7: model_pos.eval() model_encoder.eval() model_word.eval() the_sample = randint(0, len(X) - 1) Ys, Ytrees = predict_batch(model_pos, model_encoder, model_word, X[the_sample], corpus) print('Trigger a show!') print('input sentence:', X[the_sample]) print('true answer:', Y[the_sample]) print('output sentence:', Ys[0]) print_tree(Ytrees[0], show_index=True) print('epoch: {0}, pos_loss:{1}, decoder_loss:{2}, sentence/s: {3}'.format( epoch, pos_loss, decoder_loss, int(len(X) / (time.time() - start_time)))) global_pos_losses.append(pos_loss) global_decoder_losses.append(decoder_loss) if epoch % args.save_every == 0: print('saving checkpoint at epoch {0}'.format(epoch)) model_save('models.checkpoint')
def test_gen_tree_instance(): generator = GenTreeInstance() tree1 = generator.generate(levels=3) generator.reset() tree2 = generator.generate(levels=2) print('First tree') print_tree(tree1) print('Second tree') print_tree(tree2)
def test_gen_tree_class(): generator = GenTreeClass() tree1 = generator.generate(levels=3) print(f'Counter between calls {GenTreeClass.counter}') tree2 = generator.generate(levels=2) print('First tree') print_tree(tree1) print('Second tree') print_tree(tree2) print(f'Counter in the end {GenTreeClass.counter}')
def sen2tree(sen, strategy, flag=False): if len(sen) == 1: thetree = Tree(sen[0]) thetree.left = Tree('<end>') thetree.right = Tree('<end>') thetree.make_index() return thetree elif len(sen) == 0: return Tree('<end>') if args.strategy == 'L2R': if not flag: thetree = Tree('<start>') thetree.left = Tree('<end>') thetree.right = sen2tree(sen, strategy, True) thetree.make_index() print_tree(thetree) return thetree else: thetree = Tree(sen[0]) thetree.left = Tree('<end>') thetree.right = sen2tree(sen[1:], strategy, True) return thetree elif args.strategy == 'R2L': if not flag: thetree = Tree('<start>') thetree.right = Tree('<end>') thetree.left = sen2tree(sen, strategy, True) thetree.make_index() print_tree(thetree) return thetree else: thetree = Tree(sen[-1]) thetree.right = Tree('<end>') thetree.left = sen2tree(sen[0:len(sen) - 1], strategy, True) return thetree elif args.strategy == 'MID': mid = (len(sen) + 1) // 2 if flag: mid = len(sen) // 2 root = '<start>' if flag: root = sen[mid] thetree = Tree(root) if flag: thetree.right = sen2tree(sen[mid + 1:], strategy, True) else: thetree.right = sen2tree(sen[mid:], strategy, True) thetree.left = sen2tree(sen[0:mid], strategy, True) #thetree.right = sen2tree(sen[mid:], strategy, True) if not flag: thetree.make_index() return thetree
def cluster(values): data = [] for i in values: data.append(Tree(i)) dl = len(data) # Create Initial Clusters # cluster[i] = [data,size,parent,children] cluster = [] rcluster = [] for datum in data: cluster.append(datum) rcluster.append(datum) # Create Similarity Matrix sim = create_sim(data) # Main Loop #print("The Data:") #print(data) print("\nThe Dendrogram:") size = np.shape(sim) while (len(rcluster) > 1): #print(cluster) min = (0, 1) min_d = sim.item(min) for i in range(size[0]): for j in range(size[1]): if (i != j) & (sim.item((i, j)) < min_d): min = (i, j) min_d = sim.item(min) sim = union(cluster, rcluster, sim, min[0], min[1]) size = np.shape(sim) print("\nFull Cluster:") tree.print_tree(cluster[-1], 5) plt.hist(values, bins=20) plt.show()
def test_omml_tree(xml_content): #get_childrens(paragraph, []) obj = Tag2Method() codeObj = Name2Code() f = [] tree = XML(xml_content) display_zone = OMML_NAMESPACE+'oMathPara' inline_zone = OMML_NAMESPACE+'oMath' f_zone = OMML_NAMESPACE+'f' print 'START PARSE' for elem in tree.iter(inline_zone): tmp = obj.call_method(elem) #print tmp print 'END PARSE' new_tmp = update_tree(tmp, True) #temporary method print_tree('', new_tmp, True) save_tree(f, '', new_tmp, True) sss = codeObj.codec(new_tmp, '') print sss f = open('results/linear_code.txt', mode='wt') f.write(sss) f.close
# -*- coding: UTF-8 -*- import urllib import urllib2 import json import sys import tree if len(sys.argv) == 1: requrl = "http://v.juhe.cn/weather/index?format=1&cityname=%E6%9D%AD%E5%B7%9E&key=2130ee503b9d41e4c58d976fa80e8bb3" else: add = urllib.quote(sys.argv[1]) requrl = "http://v.juhe.cn/weather/index?format=1&cityname=" + add + "&key=2130ee503b9d41e4c58d976fa80e8bb3" req = urllib2.Request(url=requrl) res_data = urllib2.urlopen(req) res = res_data.read() s = json.loads(res) tree.print_tree(s)
import tree # -*- coding: UTF-8 -*- a = {"resultcode":"200","reason":"successed!","result":{"sk":{"temp":"24","wind_direction":"南风","wind_strength":"2级","humidity":"61%","time":"22:36"},"today":{"temperature":"21℃~29℃","weather":"多云转雷阵雨","weather_id":{"fa":"01","fb":"04"},"wind":"南风3-4 级","week":"星期日","city":"杭州","date_y":"2016年05月01日","dressing_index":"舒适","dressing_advice":"建议着长袖T恤、衬衫加单裤等服装。年老体弱者宜着针织长袖衬衫、马甲和长裤。","uv_index":"最弱","comfort_index":"","wash_index":"不宜","travel_index":"较不宜","exercise_index":"较不宜","drying_index":""},"future":{"day_20160501":{"temperature":"21℃~29℃","weather":"多云转雷阵雨","weather_id":{"fa":"01","fb":"04"},"wind":"南风3-4 级","week":"星期日","date":"20160501"},"day_20160502":{"temperature":"19℃~26℃","weather":"中雨转小雨","weather_id":{"fa":"08","fb":"07"},"wind":"西风微风","week":"星期一","date":"20160502"},"day_20160503":{"temperature":"16℃~26℃","weather":"多云转晴","weather_id":{"fa":"01","fb":"00"},"wind":"南风微风","week":"星期二","date":"20160503"},"day_20160504":{"temperature":"19℃~29℃","weather":"多云转小雨","weather_id":{"fa":"01","fb":"07"},"wind":"南风微风","week":"星期三","date":"20160504"},"day_20160505":{"temperature":"20℃~27℃","weather":"小雨","weather_id":{"fa":"07","fb":"07"},"wind":"西风微风","week":"星期四","date":"20160505"},"day_20160506":{"temperature":"16℃~26℃","weather":"多云转晴","weather_id":{"fa":"01","fb":"00"},"wind":"南风微风","week":"星期五","date":"20160506"},"day_20160507":{"temperature":"19℃~29℃","weather":"多云转小雨","weather_id":{"fa":"01","fb":"07"},"wind":"南风微风","week":"星期六","date":"20160507"}}},"error_code":0} tree.print_tree(a)
import argparse import os import header_parser import tree if __name__ == "__main__": aparser = argparse.ArgumentParser() aparser.add_argument("path_to_file") aparser.add_argument("-I", nargs="*", dest="additional_includes") args = aparser.parse_args() project_root = os.path.dirname(args.path_to_file) filename = os.path.basename(args.path_to_file) parsed_tree = header_parser.parsefile(project_root, filename, args.additional_includes) tree.print_tree(parsed_tree)
from tree import build_tree, print_tree, car_data, car_labels import random random.seed(4) tree = build_tree(car_data, car_labels) #print_tree(tree) indices = [random.randint(0, 999) for i in range(1000)] data_subset = [car_data[index] for index in indices] labels_subset = [car_labels[index] for index in indices] subset_tree = build_tree(data_subset, labels_subset) print_tree(subset_tree) from tree import car_data, car_labels, split, information_gain import random import numpy as np np.random.seed(1) random.seed(4) def find_best_split(dataset, labels): best_gain = 0 best_feature = 0 #Create features here features = np.random.choice(len(dataset[0]), 3, replace=False) for feature in features: data_subsets, label_subsets = split(dataset, labels, feature) gain = information_gain(labels, label_subsets) if gain > best_gain: best_gain, best_feature = gain, feature return best_gain, best_feature
def calculate(input_string, interactive_mode, integral_mode, pretty_mode, debug=False): if interactive_mode: print("Enter an expression to differentiate: (Type 'quit' to quit)") input_string = input(">>> ") if input_string == "quit": quit() if debug: #====================== Input Info + Preprocessing =======================# print(Fore.GREEN + "Input Information:" + Style.RESET_ALL) print(80 * "-") print(Fore.GREEN + "Input:" + Style.RESET_ALL, input_string) # Lex the input string into tokens: #-------------------------------------------------------------------------# from lexer import Lexer foo = Lexer() token_stream = foo.lex(input_string) if not token_stream: quit() #-------------------------------------------------------------------------# if debug: print(Fore.GREEN + "\nToken Stream:" + Style.RESET_ALL) # Print the token stream: cur_line_length = 0 for token in token_stream: s = str(token) if len(s) + cur_line_length > 80: std.write("\n") cur_line_length = 0 std.write(s + ", ") cur_line_length += len(s) #print("Input String Length:", len(args[1])) # Build The Expression Tree: #-------------------------------------------------------------------------# root = Tree(token_stream).build_tree(debug=False) #-------------------------------------------------------------------------# # Try to simplify the input expression tree: # Simplify the result expression tree: #UNCOMMENT THIS: Commented out temporarily for fun root = main_simplify(root) #print(Fore.GREEN+"\nNumber of nodes:"+Style.RESET_ALL, count_nodes( root )) reset_seen(root) if debug: print(Fore.GREEN + "\nNormalized input string:" + Style.RESET_ALL) print_expr(root) print("\n") print(80 * "-") print(Fore.GREEN + "Input Expression Tree:" + Style.RESET_ALL) print_tree(root) print() #print(80*"=") #print("Tree Dump:\n") #dump_tree(root, 0) #print(80*"-") #return 0 #======================== Derivative Calculating =========================# # Differentiate or integrate the expression: #-------------------------------------------------------------------------# result = None steps = [] if integral_mode: #print("In integral mode...") result = find_integral(root) else: result = find_derivative(root, show_steps=True, expr_stack=steps) for etree in steps: print_expr(etree) print() #-------------------------------------------------------------------------# if debug: print(80 * "-") print(Fore.GREEN + "Derivative Result Tree:" + Style.RESET_ALL) print_tree(result) # print("\nResult Tree Dump:") # dump_tree(result,0) print(80 * "-") print(Fore.GREEN + "Derivative Result Expression:" + Style.RESET_ALL) print_expr(result) print("\n") # Simplify the result expression tree: simp = main_simplify(result) if debug: print(80 * "-") print(Fore.GREEN + "Simplified Derivative Result Tree:" + Style.RESET_ALL) print_tree(simp) print() print(80 * "-") print(Fore.GREEN + "Simplified Derivative Result Expression:" + Style.RESET_ALL) answer = create_expr(simp) #answer = create_latex_expr( simp ) answer = replace_to_simplify(answer) if pretty_mode: pretty_print(answer) else: print(answer) #print("\n") else: if interactive_mode: std.write(Fore.GREEN + "Result:" + Style.RESET_ALL) answer = create_expr(simp) #answer = create_latex_expr( simp ) answer = replace_to_simplify(answer) answer = answer.replace("*", "") if pretty_mode: pretty_print(answer) else: print(answer) #print("\n") del (root) return answer
import pdb from collections import deque from tree import TreeNode, build_tree, print_tree, serialize_tree # build a sample tree root = build_tree([3, 1, 7, -3, 2, 4, 9]) print_tree(root) ################### # DFS using a stack ################### print("DFS") stack = [] # to go down the tree and backtrack up current = root while stack or current: # Finish when nothing to go down or backtrack while current: # go down until left most leafnode stack.append(current) current = current.left current = stack.pop() print(current.val) current = current.right ################### # BFS using a queue ################### print("BFS")
def dirsize(root_info, root_name, depth=False): try: tree.print_tree(root_info, root_name, depth) except TypeError: print("Please scan some folder first")
import tree import os import torch from tree import Tree, print_tree thetree = Tree('<start>') thetree.insert_son(0, 'you') thetree.insert_son(0, 'banana') thetree.make_index() print_tree(thetree, True) thetree.insert_son(0, 'Maybe') thetree.insert_son(0, 'have') thetree.make_index() thetree.insert_son(4, 'a') thetree.insert_son(4, '.') thetree.make_index() print_tree(thetree, True) thetree.insert_son(0, '<end>') thetree.insert_son(0, '<end>') thetree.insert_son(2, '<end>') thetree.insert_son(2, '<end>') thetree.insert_son(4, '<end>') thetree.insert_son(4, '<end>') thetree.insert_son(6, '<end>') thetree.insert_son(6, '<end>') thetree.make_index() print_tree(thetree, True) thetree2 = Tree('<start>') thetree2.insert_son(0, 'have') thetree2.insert_son(0, '.')
from __future__ import (absolute_import, division, print_function, unicode_literals) import argparse from fsa import initialize_scanner from parser import parser_func from tree import print_tree parser = argparse.ArgumentParser() parser.add_argument('path', help='path to file. do not include ext.') args = parser.parse_args() scanner = initialize_scanner(args.path) tree = parser_func(scanner) print('*** PRINTING TREE. TOKENS SPLIT BY | ***') print_tree(tree)
def flatten_tree(node: Node) -> List[Node]: flatten = [] queue = [node] while queue: node = queue.pop() if node: flatten.append(node) queue.insert(0, node.right) queue.insert(0, node.left) return flatten def invert_tree_queue(root: Node) -> Node: linear_elems = flatten_tree(root) return expand_into_tree(linear_elems) if __name__ == '__main__': values = [1, 2, 5, 3, 4, 6, 7] elems = list(map(Node, values)) print(elems) # tree = generate_tree_inner(Node(), 2) # print_tree_stack2(tree) tree = expand_into_tree(elems) print('Initial tree') print_tree(tree) print('Inverted tree') inverted = invert_tree_queue(tree) print_tree(inverted)