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)