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)