def genericToTarget(generic, target_language, output_file):
try:
f = FileWriter(output_file)
if target_language == "javascript":
writer = JavascriptWriter(f)
elif target_language == "python":
writer = PythonWriter(f)
else:
raise Exception("Language not supported")
generic.accept(writer)
Logger.showInfo("Generic language constructs have been converted to target language constructs and have been written to file '" + output_file + "'.")
finally:
f.close()
def scrap_video_data(video_ids):
# video_resp = network_utils.get_video_details(video_ids)
# print video_resp
workbook = xlsxwriter.Workbook(FILE_NAME)
worksheet = workbook.add_worksheet()
row =1
logger.info("writing into file " + str(len(video_ids)))
for v_id in video_ids:
video_resp = network_utils.get_video_details(v_id)
# print video_resp
try:
if YOUTUBE_CHANNEL_ID == video_resp['items'][0]['snippet']['channelId']:
FileWriter.write_file(video_resp, workbook, worksheet, row=row)
row = row + 1
except Exception as ex:
logger.exception("exception ========")
workbook.close()
logger.info("writing into file completed.")
return video_resp
def saveCSV(self, fileName, mode):
print("Save data")
FileWriter.writeFile(self.df, fileName, mode)
def learn(
*,
policy_network,
classifier_network,
env,
max_iters,
timesteps_per_batch=1024, # what to train on
max_kl=0.001,
cg_iters=10,
gamma=0.99,
lam=1.0, # advantage estimation
seed=None,
entcoeff=0.0,
cg_damping=1e-2,
vf_stepsize=3e-4,
vf_iters=3,
expert_trajs_path='./expert_trajs',
num_expert_trajs=500,
data_subsample_freq=20,
g_step=1,
d_step=1,
classifier_entcoeff=1e-3,
num_particles=5,
d_stepsize=3e-4,
max_episodes=0,
total_timesteps=0, # time constraint
callback=None,
load_path=None,
save_path=None,
render=False,
use_classifier_logsumexp=True,
use_reward_logsumexp=False,
use_svgd=True,
**policy_network_kwargs):
'''
learn a policy function with TRPO algorithm
Parameters:
----------
network neural network to learn. Can be either string ('mlp', 'cnn', 'lstm', 'lnlstm' for basic types)
or function that takes input placeholder and returns tuple (output, None) for feedforward nets
or (output, (state_placeholder, state_output, mask_placeholder)) for recurrent nets
env environment (one of the gym environments or wrapped via baselines.common.vec_env.VecEnv-type class
timesteps_per_batch timesteps per gradient estimation batch
max_kl max KL divergence between old policy and new policy ( KL(pi_old || pi) )
entcoeff coefficient of policy entropy term in the optimization objective
cg_iters number of iterations of conjugate gradient algorithm
cg_damping conjugate gradient damping
vf_stepsize learning rate for adam optimizer used to optimie value function loss
vf_iters number of iterations of value function optimization iterations per each policy optimization step
total_timesteps max number of timesteps
max_episodes max number of episodes
max_iters maximum number of policy optimization iterations
callback function to be called with (locals(), globals()) each policy optimization step
load_path str, path to load the model from (default: None, i.e. no model is loaded)
**network_kwargs keyword arguments to the policy / network builder. See baselines.common/policies.py/build_policy and arguments to a particular type of network
Returns:
-------
learnt model
'''
nworkers = MPI.COMM_WORLD.Get_size()
if nworkers > 1:
raise NotImplementedError
rank = MPI.COMM_WORLD.Get_rank()
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.49)
U.get_session(config=tf.ConfigProto(allow_soft_placement=True,
gpu_options=gpu_options))
policy = build_policy(env,
policy_network,
value_network='copy',
**policy_network_kwargs)
set_global_seeds(seed)
np.set_printoptions(precision=3)
# Setup losses and stuff
# ----------------------------------------
ob_space = env.observation_space
ac_space = env.action_space
ob = observation_placeholder(ob_space)
with tf.variable_scope("pi"):
pi = policy(observ_placeholder=ob)
with tf.variable_scope("oldpi"):
oldpi = policy(observ_placeholder=ob)
atarg = tf.placeholder(
dtype=tf.float32,
shape=[None]) # Target advantage function (if applicable)
ret = tf.placeholder(dtype=tf.float32, shape=[None]) # Empirical return
ac = pi.pdtype.sample_placeholder([None])
kloldnew = oldpi.pd.kl(pi.pd)
ent = pi.pd.entropy()
meankl = tf.reduce_mean(kloldnew)
meanent = tf.reduce_mean(ent)
entbonus = entcoeff * meanent
vferr = tf.reduce_mean(tf.square(pi.vf - ret))
ratio = tf.exp(pi.pd.logp(ac) -
oldpi.pd.logp(ac)) # advantage * pnew / pold
surrgain = tf.reduce_mean(ratio * atarg)
optimgain = surrgain + entbonus
losses = [optimgain, meankl, entbonus, surrgain, meanent]
loss_names = ["optimgain", "meankl", "entloss", "surrgain", "entropy"]
dist = meankl
all_var_list = get_trainable_variables("pi")
# var_list = [v for v in all_var_list if v.name.split("/")[1].startswith("pol")]
# vf_var_list = [v for v in all_var_list if v.name.split("/")[1].startswith("vf")]
var_list = get_pi_trainable_variables("pi")
vf_var_list = get_vf_trainable_variables("pi")
vfadam = MpiAdam(vf_var_list)
get_flat = U.GetFlat(var_list)
set_from_flat = U.SetFromFlat(var_list)
klgrads = tf.gradients(dist, var_list)
flat_tangent = tf.placeholder(dtype=tf.float32,
shape=[None],
name="flat_tan")
shapes = [var.get_shape().as_list() for var in var_list]
start = 0
tangents = []
for shape in shapes:
sz = U.intprod(shape)
tangents.append(tf.reshape(flat_tangent[start:start + sz], shape))
start += sz
gvp = tf.add_n([
tf.reduce_sum(g * tangent)
for (g, tangent) in zipsame(klgrads, tangents)
]) #pylint: disable=E1111
fvp = U.flatgrad(gvp, var_list)
assign_old_eq_new = U.function(
[], [],
updates=[
tf.assign(oldv, newv)
for (oldv,
newv) in zipsame(get_variables("oldpi"), get_variables("pi"))
])
compute_losses = U.function([ob, ac, atarg], losses)
compute_lossandgrad = U.function([ob, ac, atarg], losses +
[U.flatgrad(optimgain, var_list)])
compute_fvp = U.function([flat_tangent, ob, ac, atarg], fvp)
compute_vflossandgrad = U.function([ob, ret],
U.flatgrad(vferr, vf_var_list))
D = build_classifier(env, classifier_network, num_particles,
classifier_entcoeff, use_classifier_logsumexp,
use_reward_logsumexp)
grads_list, vars_list = D.get_grads_and_vars()
if use_svgd:
optimizer = SVGD(
grads_list, vars_list,
lambda: tf.train.AdamOptimizer(learning_rate=d_stepsize))
else:
optimizer = Ensemble(
grads_list, vars_list,
lambda: tf.train.AdamOptimizer(learning_rate=d_stepsize))
@contextmanager
def timed(msg):
if rank == 0:
print(colorize(msg, color='yellow'))
tstart = time.time()
yield
print(
colorize("done in %.3f seconds" % (time.time() - tstart),
color='blue'))
else:
yield
def allmean(x):
assert isinstance(x, np.ndarray)
out = np.empty_like(x)
MPI.COMM_WORLD.Allreduce(x, out, op=MPI.SUM)
out /= nworkers
return out
U.initialize()
if rank == 0:
saver = tf.train.Saver(var_list=get_variables("pi"), max_to_keep=10000)
writer = FileWriter(os.path.join(save_path, 'logs'))
stats = Statistics(
scalar_keys=["average_return", "average_episode_length"])
if load_path is not None:
# pi.load(load_path)
saver.restore(U.get_session(), load_path)
th_init = get_flat()
MPI.COMM_WORLD.Bcast(th_init, root=0)
set_from_flat(th_init)
vfadam.sync()
print("Init param sum", th_init.sum(), flush=True)
# Prepare for rollouts
# ----------------------------------------
if load_path is not None:
seg_gen = traj_segment_generator(pi,
env,
1,
stochastic=False,
render=render)
else:
seg_gen = traj_segment_generator(pi,
env,
timesteps_per_batch,
stochastic=True,
render=render)
seg_gen_e = expert_traj_segment_generator(env, expert_trajs_path,
data_subsample_freq,
timesteps_per_batch,
num_expert_trajs)
episodes_so_far = 0
timesteps_so_far = 0
iters_so_far = 0
tstart = time.time()
lenbuffer = deque(maxlen=40) # rolling buffer for episode lengths
rewbuffer = deque(maxlen=40) # rolling buffer for episode rewards
if sum([max_iters > 0, total_timesteps > 0, max_episodes > 0]) == 0:
# nothing to be done
return pi
assert sum([max_iters>0, total_timesteps>0, max_episodes>0]) < 2, \
'out of max_iters, total_timesteps, and max_episodes only one should be specified'
while True:
if callback: callback(locals(), globals())
if total_timesteps and timesteps_so_far >= total_timesteps:
break
elif max_episodes and episodes_so_far >= max_episodes:
break
elif max_iters and iters_so_far >= max_iters:
break
logger.log("********** Iteration %i ************" % iters_so_far)
if iters_so_far % 500 == 0 and save_path is not None and load_path is None:
fname = os.path.join(save_path, 'checkpoints', 'checkpoint')
save_state(fname, saver, iters_so_far)
with timed("sampling"):
seg = seg_gen.__next__()
if load_path is not None:
iters_so_far += 1
logger.record_tabular("EpRew", int(np.mean(seg["ep_true_rets"])))
logger.record_tabular("EpLen", int(np.mean(seg["ep_lens"])))
logger.dump_tabular()
continue
seg["rew"] = D.get_reward(seg["ob"], seg["ac"])
add_vtarg_and_adv(seg, gamma, lam)
ob, ac, ep_lens, atarg, tdlamret = seg["ob"], seg["ac"], seg[
"ep_lens"], seg["adv"], seg["tdlamret"]
vpredbefore = seg["vpred"] # predicted value function before udpate
atarg = (atarg - atarg.mean()
) / atarg.std() # standardized advantage function estimate
if hasattr(pi, "ret_rms"): pi.ret_rms.update(tdlamret)
if hasattr(pi, "rms"):
pi.rms.update(ob) # update running mean/std for policy
args = seg["ob"], seg["ac"], atarg
fvpargs = [arr[::5] for arr in args]
def fisher_vector_product(p):
return allmean(compute_fvp(p, *fvpargs)) + cg_damping * p
assign_old_eq_new() # set old parameter values to new parameter values
with timed("computegrad"):
*lossbefore, g = compute_lossandgrad(*args)
lossbefore = allmean(np.array(lossbefore))
g = allmean(g)
if np.allclose(g, 0):
logger.log("Got zero gradient. not updating")
else:
with timed("cg"):
stepdir = cg(fisher_vector_product,
g,
cg_iters=cg_iters,
verbose=rank == 0)
assert np.isfinite(stepdir).all()
shs = .5 * stepdir.dot(fisher_vector_product(stepdir))
lm = np.sqrt(shs / max_kl)
# logger.log("lagrange multiplier:", lm, "gnorm:", np.linalg.norm(g))
fullstep = stepdir / lm
expectedimprove = g.dot(fullstep)
surrbefore = lossbefore[0]
stepsize = 1.0
thbefore = get_flat()
for _ in range(10):
thnew = thbefore + fullstep * stepsize
set_from_flat(thnew)
meanlosses = surr, kl, *_ = allmean(
np.array(compute_losses(*args)))
improve = surr - surrbefore
logger.log("Expected: %.3f Actual: %.3f" %
(expectedimprove, improve))
if not np.isfinite(meanlosses).all():
logger.log("Got non-finite value of losses -- bad!")
elif kl > max_kl * 1.5:
logger.log("violated KL constraint. shrinking step.")
elif improve < 0:
logger.log("surrogate didn't improve. shrinking step.")
else:
logger.log("Stepsize OK!")
break
stepsize *= .5
else:
logger.log("couldn't compute a good step")
set_from_flat(thbefore)
if nworkers > 1 and iters_so_far % 20 == 0:
paramsums = MPI.COMM_WORLD.allgather(
(thnew.sum(), vfadam.getflat().sum())) # list of tuples
assert all(
np.allclose(ps, paramsums[0]) for ps in paramsums[1:])
for (lossname, lossval) in zip(loss_names, meanlosses):
logger.record_tabular(lossname, lossval)
with timed("vf"):
for _ in range(vf_iters):
for (mbob, mbret) in dataset.iterbatches(
(seg["ob"], seg["tdlamret"]),
include_final_partial_batch=False,
batch_size=1000):
g = allmean(compute_vflossandgrad(mbob, mbret))
vfadam.update(g, vf_stepsize)
with timed("sample expert trajectories"):
ob_a, ac_a, ep_lens_a = ob, ac, ep_lens
seg_e = seg_gen_e.__next__()
ob_e, ac_e, ep_lens_e = seg_e["ob"], seg_e["ac"], seg_e["ep_lens"]
if hasattr(D, "rms"):
obs = np.concatenate([ob_a, ob_e], axis=0)
if isinstance(ac_space, spaces.Box):
acs = np.concatenate([ac_a, ac_e], axis=0)
D.rms.update(np.concatenate([obs, acs], axis=1))
elif isinstance(ac_space, spaces.Discrete):
D.rms.update(obs)
else:
raise NotImplementedError
with timed("SVGD"):
sess = tf.get_default_session()
feed_dict = {
D.Xs['a']: ob_a,
D.As['a']: ac_a,
D.Ls['a']: ep_lens_a,
D.Xs['e']: ob_e,
D.As['e']: ac_e,
D.Ls['e']: ep_lens_e
}
for _ in range(d_step):
sess.run(optimizer.update_op, feed_dict=feed_dict)
logger.record_tabular("ev_tdlam_before",
explained_variance(vpredbefore, tdlamret))
lrlocal = (seg["ep_lens"], seg["ep_true_rets"]) # local values
listoflrpairs = MPI.COMM_WORLD.allgather(lrlocal) # list of tuples
lens, rews = map(flatten_lists, zip(*listoflrpairs))
lenbuffer.extend(lens)
rewbuffer.extend(rews)
logger.record_tabular("EpLenMean", np.mean(lenbuffer))
logger.record_tabular("EpRewMean", np.mean(rewbuffer))
logger.record_tabular("EpThisIter", len(lens))
episodes_so_far += len(lens)
timesteps_so_far += sum(lens)
iters_so_far += 1
logger.record_tabular("EpisodesSoFar", episodes_so_far)
logger.record_tabular("TimestepsSoFar", timesteps_so_far)
logger.record_tabular("TimeElapsed", time.time() - tstart)
if rank == 0:
logger.dump_tabular()
stats.add_all_summary(
writer,
[np.mean(rewbuffer), np.mean(lenbuffer)], iters_so_far)
rewbuffer.clear()
lenbuffer.clear()
return pi
def main():
path_to_dataset = "C:\\GIT\\ZIWM\\data.csv"
file_writer = FileWriter("")
total_number_of_classes = 8
total_number_of_features = 30
num_of_neighbours = [1, 5, 10]
type_of_metric = ["euclidean", "manhattan"]
#loading raw values from file
datasetLoader = load_datasets.Load_datasets(path_to_dataset)
dataset_raw_values = datasetLoader.loadDataset()
#constructing main dataset with division for features and classes
dataset = Dataset(dataset_raw_values)
best_fit = 0.0
best_average_fit = 0.0
# selecting number of features and running tests
for number_of_features_selected in range(1, 31):
#print(number_of_features_selected)
trimmed_feature_list = FeatureSelector.selectKBestFeatures(
number_of_features_selected, dataset.dataset_features_array,
dataset.dataset_class_array)
# dividing data sets into patients
patients = []
for i in range(len(dataset.dataset_class_array)):
patient = Patient(i, dataset.dataset_class_array[i],
trimmed_feature_list[i])
# print(patient.getId(), patient.getDisease_class(), patient.get_features())
patients.append(patient)
# testing for each metric type and number of neighbours
for metric in type_of_metric:
for n_neighbours in num_of_neighbours:
test_result_arr = []
for i in range(5):
print("metric: ", metric, " n_neighbours", n_neighbours,
" run: ", i)
# creating learn and test data sets
learning_set, testing_set = SplitSets.splitSets(patients)
# creating algorythm and training
kn = KNearestNeighbour(n_neighbours, metric, learning_set,
testing_set)
kn.train()
res1 = kn.test()
# swaping training and learning sets
temp_set = learning_set
learning_set = testing_set
testing_set = temp_set
kn.setTestSet(testing_set)
kn.setTrainingSet(learning_set)
# training once again
kn.train()
res2 = kn.test()
print("test result 1: ", res1)
print("test result 2: ", res2)
test_result_arr.append(res1)
test_result_arr.append(res2)
if (res1 > best_fit):
best_fit = res1
if (res2 > best_fit):
best_fit = res2
test_average = sum(test_result_arr) / len(test_result_arr)
print("average of tests: ", test_average)
result_str = str(number_of_features_selected
) + " | " + metric + " | " + str(
n_neighbours) + " | " + str(
test_average) + " \n"
file_writer.write(result_str)
if (test_average > best_average_fit):
best_average_fit = test_average
# comparing results of test data set
# calculating hit rate
print("best fit: ", best_fit)
print("best fit average: ", best_average_fit)
file_writer.close()
def get_test_file_list(test_file_path):
print(test_file_path)
f = []
for (dirpath, dirnames, filenames) in walk(test_file_path):
f.extend(filenames)
break
return f
# criterion - parameter : The function to measure the quality of a split. Supported criteria are “gini” for the Gini impurity and “entropy” for the information gain.
criterions_array = ["gini", "entropy"]
# splitter - parameter : The strategy used to choose the split at each node. Supported strategies are “best” to choose the best split and “random” to choose the best random split.
spliters_array = ["best", "random"]
file_writer = FileWriter("C:\\aa.txt")
# load all files
files_loaded = get_test_file_list(get_current_test_file_path())
print(get_current_test_file_path())
print(get_test_file_list(get_current_test_file_path()))
#for each file run experiment
for file in files_loaded:
# load data from file
file_name = file
file_path = os.getcwd() + "\\test_data\\" + file_name
print(file_name)