def __init__(self):
self.inodes = {b'.': llfuse.ROOT_INODE}
storage = DictStorage()
self.forest = forest.Forest(storage)
self.ops = ops.Operations(self.forest)
self.rctx_root = RequestContextIsh()
self.rctx_user = RequestContextIsh(uid=42, gid=7, pid=123)
self.ops.init()
# Create root-owned directory + file + file in directory
self.mkdir(llfuse.ROOT_INODE, b'root_dir', self.rctx_root)
self.create(llfuse.ROOT_INODE,
b'root_file',
self.rctx_root,
data=b'root')
self.create(self.inodes[b'root_dir'],
b'root_file_in',
self.rctx_root,
data=b'root2')
# Create user-owned directory + file
self.mkdir(llfuse.ROOT_INODE, b'user_dir', self.rctx_user)
self.create(llfuse.ROOT_INODE,
b'user_file',
self.rctx_user,
data=b'user')
self.create(self.inodes[b'user_dir'],
b'user_file_in',
self.rctx_user,
data=b'user2')
# Ensure that stuff with 0 refcnt is gone?
self.forest.flush()
def __init__(self, *, storage=None):
storage = storage or st.DictStorage()
self.forest = forest.Forest(storage)
self.ops = ops.Operations(self.forest)
self.rctx_root = llfuse.RequestContext()
self.rctx_user = llfuse.RequestContext(uid=42, gid=7, pid=123)
self.ops.init()
def predict2():
trainingRowIds = random.sample(range(1, len(data)), int(.01 * len(data)))
f = forest.Forest(data, outcomeLabel, continuousAttributes, trainingRowIds)
correct = sum(1 for rowId, row in enumerate(data)
if rowId > 0 and rowId not in trainingRowIds
and f.get_prediction(row) == row[outcomeLabelIndex])
return 100 * correct / (len(data) - 1 - len(trainingRowIds))
def main(forest_file, nbest_file, weight_string, exhaustive=False):
exhaustive = False
ffile = open(forest_file, "r")
nfile = open(nbest_file, "r")
weights = forest.read_features(weight_string)
expr = re.compile(
'.*sent=(\d+).*nbest=(\d+).*totalcost=(\S+).*derivation={{{(.*?)}}}.*')
sent = -1
count = 0
kbest = 0
f = forest.Forest([])
passed = True
for line in nfile:
m = re.match(expr, line)
count = int(m.group(2))
if sent != int(m.group(1)):
sent = int(m.group(1))
f = forest.read_forest(ffile.readline())
if exhaustive:
kbest = forest.kbest(f, weights)
deriv = forest.read_tree(m.group(4))
cost = float(m.group(3))
if exhaustive:
fderiv = kbest.next()
else:
fintersect = forest.kbest(forest.intersect_forest_tree(f, deriv),
weights)
fderiv = fintersect.next()
empty = False
try:
fffff = fintersect.next()
except StopIteration:
empty = True
assert (empty)
s = fderiv.score #forest.inner_prod(fderiv.features,weights)
if abs(s - cost) > 0.01:
print "==="
print "%s: %s vs %s" % (count, s, cost)
print deriv
print fderiv
print line
print "==="
passed = False
count += 1
if passed:
print "passed"
else:
print "failed"
def makeForest(self):
"""Create a forest, represented as a collection of roots and a
dictionary of children, from the information contained in the
src array."""
children = {}
roots = []
for v in self.src.keys():
children[v] = []
for (u, v) in self.src.items():
if v == None:
roots.append(u)
else:
children[v].append(u)
return forest.Forest(roots, children)
def ensure_storage_matches_forest(self):
f2 = forest.Forest(self.forest.storage)
ops2 = ops.Operations(f2).init()
todo = [(b'.', self.ops.lookup(llfuse.ROOT_INODE, b'.',
self.rctx_root),
ops2.lookup(llfuse.ROOT_INODE, b'.', self.rctx_root))]
while todo:
p, a1, a2 = todo.pop()
_debug('considering %s', p)
ad1 = attr_to_dict(a1)
ad2 = attr_to_dict(a2)
ad1.pop('st_ino')
ad2.pop('st_ino')
_debug(' ad1: %s', ad1)
_debug(' ad2: %s', ad2)
inode1 = self.forest.inodes.get_by_value(a1.st_ino)
inode2 = f2.inodes.get_by_value(a2.st_ino)
# TBD: What needs to be popped?
assert ad1 == ad2
if stat.S_ISDIR(a1.st_mode):
# Moar TODO to be had! Yay
for (n1, na1, o1), (n2, na2,
o2) in zip(self.ops.readdir(a1.st_ino, 0),
ops2.readdir(a2.st_ino, 0)):
assert n1 == n2
na1 = self.ops.lookup(a1.st_ino, n1, self.rctx_root)
na2 = ops2.lookup(a2.st_ino, n2, self.rctx_root)
todo.append((b'%s/%s' % (p, n1), na1, na2))
elif stat.S_ISREG(a1.st_mode):
# Ensure that what we know underneath matches direntry..
s = inode1.size
assert s == inode2.size
assert s == inode1.stored_size
assert s == inode2.stored_size
if s <= 10 * const.BLOCK_SIZE_LIMIT:
assert inode1.read(0, s) == inode2.read(0, s)
else:
assert inode1.read(0, 1) == inode2.read(0, 1)
assert inode1.read(s // 2, 1) == inode2.read(s // 2, 1)
assert inode1.read(s - 1, 1) == inode2.read(s - 1, 1)
self.ops.forget1(a1.st_ino)
ops2.forget1(a2.st_ino)
def __init__(self, pace, pretrain_model, train_txt, iterations_update_forest,
lr=0.05, num_trees=5, tree_depth=6, num_classes=67, predict=False):
self.num_trees = num_trees
self.num_classes = num_classes
self.leaf_node_num = 2 ** (tree_depth - 1)
self.lr = lr
self.feat_layer = VGG_16()
forest = ndf.Forest(n_tree=num_trees, tree_depth=tree_depth, n_in_feature=2622,
num_classes=num_classes, iterations_update_forest=iterations_update_forest)
model = ndf.NeuralDecisionForest(self.feat_layer, forest)
model = model.cuda()
self.model = model
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
if not predict and pace < 2:
print('load model from %s' % pretrain_model[0])
self.feat_layer.load_weights(path=pretrain_model[0])
init_mean, init_sigma = self.kmeans_label(train_txt)
self.model.forest.dist.init_kmeans(init_mean, init_sigma)
def __init__(self, list_dir, num_tree=5, depth=6, task_num=1):
#super(Forest, self).__init__()
feat_layer = VGG_16()
feat_layer.load_weights()
forest = ndf.Forest(n_tree=num_tree, tree_depth=depth, n_in_feature=128)
model = ndf.NeuralDecisionForest(feat_layer, forest)
self.leaf_node_num = 2 ** (depth - 1)
model = model.cuda()
self.model = model
#self.dist = Pi(num_tree, self.leaf_node_num)
init_mean, init_sigma = self.kmeans_label(list_dir)
self.model.forest.dist.init_kmeans(init_mean, init_sigma)
#self.optimizer = torch.optim.Adam(self.model.parameters(),lr=0.05, betas=(0.5, 0.999))
lr = 0.05
#conv1_w, conv1_b, conv2_fc8_w, conv2_fc8_b, linear_w, linear_b = find_params(self.model)
# print(len(conv1_w), len(conv1_b), len(conv2_fc8_w), len(conv2_fc8_b), len(linear_w), len(linear_b))
# input()
# self.optimizer = torch.optim.SGD([{'params':conv1_w, 'lr':0.05}, {'params':conv1_b, 'lr':0.05, 'weight_decay':0},\
# {'params':conv2_fc8_w, 'lr':0.05}, {'params':conv2_fc8_b, 'lr':0.05, 'weight_decay':0},\
# {'params':linear_w, 'lr':0.05},{'params':linear_b, 'lr':0.05, 'weight_decay':0}], lr=0.05, momentum=0.9)
param_list = feat_layer.get_weight_dict(lr)
self.optimizer = torch.optim.SGD(param_list, lr=0.05, momentum=0.9)
#self.optimizer = torch.optim.SGD([{'params':self.model.parameters(), 'lr':0.2}], lr=0.05, momentum=0.9)
self.optimizers = [self.optimizer]
def lambda_rule(iteration):
if iteration < 10000:
lr_l = 1
if 10000 <= iteration and iteration < 20000:
lr_l = 0.5
# if 10000 <= iteration and iteration < 15000:
# lr_l = 0.5 ** 2
# if 15000 <= iteration and iteration < 20000:
# lr_l = 0.5 ** 3
# if 20000 <= iteration and iteration < 25000:
# lr_l = 0.5 ** 4
if iteration >= 20000:
lr_l = 0.5 ** 2
return lr_l
self.schedulers = [lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule) for optimizer in self.optimizers]
def __init__(self):
pygame.init()
self._screen = pygame.display.set_mode(__screenSize__)
self._font = pygame.font.SysFont('Arial',20)
self._forest = ft.Forest()
# input boxes for parameters
self._input_boxes["humidity"] = ibox.InputBox(920, 465, 100, 30, self._screen, ft.HUMIDITY * 100, 100, 0.0, float, increment=1, decimals=1)
self._input_boxes["lightning"] = ibox.InputBox(920, 525, 100, 30, self._screen, ft.LIGHTNING * 100, 100, 0.0, float, increment=0.001, decimals=3)
self._input_boxes["new_growth"] = ibox.InputBox(920, 585, 100, 30, self._screen, ft.NEW_GROWTH * 100, 100, 0.0, float, increment=0.1, decimals=1)
self._input_boxes["wind_strength"] = ibox.InputBox(1110, 720, 25, 30, self._screen, ft.WIND_STRENGTH, ft.WIND_MAX, 0, int, min_width=25, writeable=False)
# buttons for wind direction
self._wind_buttons["none"] = ibut.InputButton(1120, 650, 15, 15, self._screen, active=True)
self._wind_buttons["north"] = ibut.InputButton(1100, 620, 55, 25, self._screen, text=str(ft.WINDS[1][2]))
self._wind_buttons["east"] = ibut.InputButton(1155, 645, 55, 25, self._screen, text=str(ft.WINDS[2][2]))
self._wind_buttons["south"] = ibut.InputButton(1100, 670, 55, 25, self._screen, text=str(ft.WINDS[3][2]))
self._wind_buttons["west"] = ibut.InputButton(1045, 645, 55, 25, self._screen, text=str(ft.WINDS[4][2]))
# buttons for wind strength
self._ws_buttons["minus"] = ibut.InputButton(1080, 725, 20, 20, self._screen, text="-", blink=True)
self._ws_buttons["plus"] = ibut.InputButton(1145, 725, 20, 20, self._screen, text="+", blink=True)
destination, timemin = ft.initialize_simulators(Sims,
ntra,
STATE_INIT,
missionheading,
plot=True)
print("destination : {} & timemin : {}".format(destination, timemin))
""" Create a Forest and launch a PMCTS """
##Exploration Parameters##
worker.RHO = 0.5 # Proportion between master utility and worker utility of node utility.
worker.UCT_COEFF = 1 / 2**0.5 # Exploration coefficient in the UCT formula.
budget = 100 # number of nodes we want to expand in each worker
frequency = 10 # number of steps performed by worker before writing the results into the master
forest = ft.Forest(listsimulators=Sims,
destination=destination,
timemin=timemin,
budget=budget)
master_nodes = forest.launch_search(STATE_INIT, frequency)
new_dict = deepcopy_dict(master_nodes)
forest.master = MasterTree(Sims, destination, nodes=new_dict)
forest.master.get_best_policy()
forest.master.plot_tree_uct()
forest.master.plot_tree_uct(1)
forest.master.plot_hist_best_policy(interactive=True)
forest.master.save_tree("my_tuto_results")
"""""" " Isochrones " """"""
""" Launch a search """
Boat.UNCERTAINTY_COEFF = 0
NUMBER_OF_SIM = 3 # <=20
SIM_TIME_STEP = 6 # in hours
if __name__ == '__main__':
ft.LIGHTNING = 0
ft.NEW_GROWTH = 0
ft.WIND = 1
ft.WIND_STRENGTH = 1
ft.RIVER = None
ft.CLOUDS = None
densities = [d for d in np.arange(0.01, 1, 0.01)]
percentageBurnt = []
for density in densities:
ft.TREE_RATIO = density
forest = ft.Forest()
done = False
while done == False:
forest.update()
if forest._burnt == 0:
#print("No more burning trees")
done = True
continue
perc = (1 - (forest._tree / forest._init)) * 100
percentageBurnt.append(perc)
print(
f"For density {density:.2f}, {perc:.2f}% of the trees have burnt")
N_DAYS_SIM = 4 # time horizon in days
sims = ft.create_simulators(Weathers, numberofsim=NUMBER_OF_SIM, simtimestep=SIM_TIME_STEP,
stateinit=STATE_INIT, ndaysim=N_DAYS_SIM)
# ft.play_multiple_scenarios(sims)
# sims[0].play_scenario()
# initialize the simulators to get common destination and individual time min
missionheading = 0
ntra = 50
destination, timemin = ft.initialize_simulators(sims, ntra, STATE_INIT, missionheading)
print("destination : " + str(destination) + " & timemin : " + str(timemin) + "\n")
forest = ft.Forest(listsimulators=sims, destination=destination, timemin=timemin)
ntra = 100
tree = forest.workers[0]
endpoint = []
endtimes = []
rewards = []
for i in range(ntra):
tree.Simulator.state = list(STATE_INIT)
dist, action = tree.Simulator.getDistAndBearing(tree.Simulator.state[1:], tree.destination)
atDest, frac = Tree.is_state_at_dest(tree.destination, tree.Simulator.prevState, tree.Simulator.state)
codec = st.CompressingTypedBlockCodec(codec)
else:
codec = st.TypedBlockCodec(codec)
if args.backend == 'lmdb':
backend = stlm.LMDBStorageBackend(
codec=codec, filename=args.filename)
else:
backend = stsql.SQLiteStorageBackend(
codec=codec, filename=args.filename)
storage = st.DelayedStorage(backend=backend)
storage.maximum_cache_size = args.cache_size
else:
storage = st.DictStorage()
forest = forest.Forest(storage)
ops = ops.Operations(forest)
fuse_options = set(llfuse.default_options)
fuse_options.remove('nonempty') # TBD..
fuse_options.add('fsname=test_fs')
# fuse_options.add('large_read') # n/a on OS X?
# fuse_options.add('blksize=%d' % const.BLOCK_SIZE_LIMIT) # n/a on OS X?
fuse_options.add('max_read=%d' % (const.BLOCK_SIZE_LIMIT * 10))
fuse_options.add('max_write=%d' % (const.BLOCK_SIZE_LIMIT * 10))
fuse_options.add('slow_statfs')
# fuse_options.add('novncache') # this works but what does it do?
# fuse_options.add('noattrcache') # this works but what does it do?
fuse_options.add('allow_other')
if args.debug:
fuse_options.add('debug')
llfuse.init(ops, args.mountpoint, fuse_options)
n.SIZE_OF_SAMPLE = int(sys.argv[3])
reader = dr.Reader()
reader.fetch_data()
numpy_data = reader.get_numpy_data()
data = reader.get_data()
if numpy_data.__sizeof__() == 0:
print("Nie udało się pobrać danych")
exit(1)
if data == []:
print("Nie udało się pobrać danych")
exit(1)
forest = forest.Forest(n.NUMBER_OF_STUMPS)
before = datetime.now()
forest.fit_forest_to_data(n.SIZE_OF_SAMPLE, data)
after = datetime.now()
diff = after - before
print("Czas dostosowania lasu dla całej próbki danych:",
"%.3f" % (diff.total_seconds() * 1000), 'ms')
before = datetime.now()
validate.cross_validate(int(1 / n.TEST_DATA_PERCENTAGE), forest, data)
after = datetime.now()
diff = after - before
print("Czas wykonania walidacji:", "%.3f" % (diff.total_seconds()), 's')
exit(0)
