import numpy as np
import time
import tensorflow as tf
from copy import copy
from data import get_all_data
from model import Model
from environment import evaluate_logp, evaluate
from utils import save, load
import sys
def info(*args):
print(*args, file=sys.stdout, flush=True)
records = load("records")
for record in records:
decisions = [[1, 7] for _ in range(len(record["cgroups"]))]
info(record["best"][1], record["best_single"][1],
evaluate(record, decisions))
],
training=True) # TODO: nodes that are already placed
nodelogit = tf.reshape(nodelogit, strategy.shape)
group_mask = np.zeros(nodelogit.shape, dtype=np.float32)
for i in record['op_groups'][gid]:
group_mask[i, :] = 1
p = sample(nodelogit.numpy())
negative_logp += tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
tf.convert_to_tensor(p, dtype=tf.float32), nodelogit) *
group_mask)
for i in record['op_groups'][gid]:
strategy[i, :] = p[i, :]
sqrt_time = evaluate(record, np.zeros((op_feats.shape[0], )),
strategy)[0]
if "hist" not in record:
record["hist"] = [sqrt_time]
else:
record["hist"].append(sqrt_time)
record["hist"] = record["hist"][-100:]
baseline = np.mean(record["hist"])
advantage = -(sqrt_time - baseline) / baseline
loss = advantage * negative_logp
# ncclmask, nodemask, advantage, sqrt_time, oom, leftout = sample_and_evaluate(record, nccllogit.numpy(), nodelogit.numpy()) # numpy to turn off gradient tracking
# for i in oom:
# negative_logp = tf.nn.sigmoid_cross_entropy_with_logits([0.] * nodelogit.shape[1], nodelogit[i, :])
# loss += .01 * tf.reduce_sum(negative_logp)
# for gi in leftout:
# negative_logp = tf.nn.sigmoid_cross_entropy_with_logits([1.] * nodelogit.shape[0], nodelogit[:, gi])
#!/usr/bin/python39
from environment import evaluate, debug_draw_errors
# Static side effects
const_velocity = None
def simple_controller(velocity, terrain):
global const_velocity
if const_velocity is None:
# Assume the first input as the speed we want to keep
const_velocity = velocity
if velocity > const_velocity: action = 0.1
else: action = 1
return action
if __name__ == '__main__':
nfailed, errors = evaluate(simple_controller, silent=False)
print(f'Car stuck inside valley {nfailed} times')
debug_draw_errors(errors).show()
import parser
import exc
import environment
if __name__ == '__main__':
import sys
code = sys.stdin.read()
try:
rst = list(parser.parsing(code))
env = environment.Environment(environment.INITIAL_ENV, None)
env['env'] = env
ret_value = map( lambda rst:environment.evaluate(env, rst), rst)
except exc.SyntaxError as e:
e.display_error()
else:
print 'implement result : ', ret_value
if loss_new <= loss_old:
return 1
else:
return np.exp(1 - 1 / T)
record = get_all_data()[2]
# decisions = [ [1, 7] for _ in range(len(record["cgroups"])) ]
# evaluate(record, decisions)
# sys.exit(0)
s, baseline = None, 9999
for nccl in range(2):
for i in range(8):
decisions = [ [nccl, i] for _ in range(len(record["cgroups"])) ]
loss = evaluate(record, decisions)
info(decisions, loss)
if loss < baseline:
s, baseline = decisions, loss
loss = 1
best = 1
for epoch in range(20000):
T = (0.5 * epoch + 10000) / 20000
s_new = neighbour(s)
loss_new = evaluate(record, s_new) / baseline
if loss_new < best:
best = loss_new
if P(loss, loss_new, T) > np.random.rand():
s, loss = s_new, loss_new
info(epoch, loss, best)
#!/usr/bin/python39
from environment import evaluate, debug_draw_errors
import matlab
import matlab.engine
eng = matlab.engine.start_matlab()
def load_controller(filename):
matlab_controller = eng.readfis(filename)
def controller(velocity, terrain):
inp = matlab.double([velocity, terrain])
action = eng.evalfis(matlab_controller, inp)
return action
return controller
SIT215_controller = load_controller('PBL_Task_1.fis')
nfailed, errors = evaluate(SIT215_controller,silent=False)
print(f'Car stuck inside valley {nfailed} times')
debug_draw_errors(errors).show()