def create_net(pkl_dir, mnt): pkl_file_list = util.get_file_list(pkl_dir, '.pkl') m_dict = {} # 按照年月来分类所有的文件 for file_name in pkl_file_list: fm = file_name[0:7] # 获取 mf_list = m_dict.get(fm, []) if mf_list is None: mf_list = [file_name] else: mf_list.append(file_name) m_dict[fm] = mf_list # 创建存放按照月份创建的pkl目录 util.create_directory(mnt) # 合并一个月内的所有网络 for (k, vl) in m_dict.items(): mg = nx.Graph() print(k) for file in vl: g1 = util.get_nw(pkl_dir + file) mg = nx.compose(mg, g1) util.save_nw(mg, mnt + k)
def __init__(self, interactor_queue, lock, config, env_config, learner_config, **bonus_kwargs): self.learner_name = self.learner_name() self.interactor_queue = interactor_queue self.learner_lock = lock self.config = config self.env_config = env_config self.learner_config = learner_config self.bonus_kwargs = bonus_kwargs self.kill_threads = False self.permit_desync = False self.need_frames_notification = threading.Condition() self._reset_inspections() self.total_frames = 0 self.save_path = util.create_directory("%s/%s/%s/%s" % (self.config["output_root"], self.config["env"]["name"], self.config["name"], self.config["save_model_path"])) self.log_path = util.create_directory("%s/%s/%s/%s" % (self.config["output_root"], self.config["env"]["name"], self.config["name"], self.config["log_path"])) + "/%s.log" % self.learner_name # replay buffer to store data self.replay_buffer_lock = threading.RLock() self.replay_buffer = ReplayBuffer(self.learner_config["replay_size"], np.prod(self.env_config["obs_dims"]), self.env_config["action_dim"]) # data loaders pull data from the replay buffer and put it into the tfqueue for model usage self.data_loaders = self.make_loader_placeholders() queue_capacity = np.ceil(1./self.learner_config["frames_per_update"]) if self.learner_config["frames_per_update"] else 100 self.tf_queue = tf.FIFOQueue(capacity=queue_capacity, dtypes=[dl.dtype for dl in self.data_loaders]) self.enqueue_op = self.tf_queue.enqueue(self.data_loaders) self.current_batch = self.tf_queue.dequeue() # build the TF graph for the actual model to train self.core, self.train_losses, self.train_ops, self.inspect_losses = self.make_core_model() self.sess = tf.Session() self.sess.run(tf.global_variables_initializer())
def __write_service_file(path, data): create_directory( os.path.join(GitClient.CHECKOUT_DIR, os.path.dirname(path))) with (open(os.path.join(GitClient.CHECKOUT_DIR, path), 'w')) as service_file: yaml.dump(data, service_file, default_flow_style=False, allow_unicode=False)
def log_config(): HPS_PATH = util.create_directory("output/" + config["env"]["name"] + "/" + config["name"] + "/" + config["log_path"]) + "/hps.json" print("ROOT GPU: " + str(args.root_gpu) + "\n" + str(cstr)) with open(HPS_PATH, "w") as f: f.write("ROOT GPU: " + str(args.root_gpu) + "\n" + str(cstr))
def __init__(self, options, exefile='mainFeatures'): """ Initialize the different parameters for calling CPP program and provides main interface function to compute features... ftype= features type among [LBP, LTP, LBP+LTP] featdir= directory path for storing feature files. listfile= list file containing absolute path of images for computing features... """ self.display(options) ftype = options.ftype.upper() if not ftype in ["LQP", "LBP", "LTP", "LBP+LTP"]: print 'Error: Any one of the following Feature Types should be chosen "LQP","LBP","LTP","LBP+LTP", not %s' % ftype raise ValueError self.ftype = options.ftype; if not os.path.exists(options.featdir): print 'Making Directory =', options.featdir # os.mkdir(options.featdir) u.create_directory(options.featdir) self.featdir = options.featdir; if not os.path.exists(options.listfile): print "Error: Given file(%s) for list of images does not exist " % options.listfile raise ValueError self.listfile = options.listfile self.rdir = os.getcwd() # root directory self.exe = os.path.normpath(os.path.join(self.rdir, os.path.join(os.pardir, os.pardir), 'build', exefile)) values = {'exefile':self.exe, 'color_channel':4, 'add_rgb':1, 'norm_sep':0, 'cell_size':options.cellsize, 'lbp_stride':options.cellsize, 'width':options.width, 'height':options.height, 'listfile':options.listfile, 'cbfile':options.cbfile } cmd = string.Template("${exefile} --Color-Channel=${color_channel} " " --Add-RGBLBP=${add_rgb} --Norm-Sep=${norm_sep} " " --Cell-Size=${cell_size} --LBP-Stride=${lbp_stride} " " --Win-Width=${width} --Win-Height=${height} --Validation-File=${cbfile}" " --TrainingFile=${listfile}") cmd = cmd.safe_substitute(values) self.dirs = [] # contain the name of feature directories... cwd = os.getcwd() if self.ftype == "LQP": self.compute_lqp(cmd, options) else: self.compute_localpattern(cmd, options) os.chdir(cwd)
def __init__(self, interactor_queue, lock, config, env_config, learner_config, **bonus_kwargs): self.learner_name = self.learner_name() self.interactor_queue = interactor_queue self.learner_lock = lock self.config = config self.env_config = env_config self.learner_config = learner_config self.bonus_kwargs = bonus_kwargs self.kill_threads = False self.permit_desync = False self.need_frames_notification = threading.Condition() self._reset_inspections() self.total_frames = 0 self.save_path = util.create_directory( "%s/%s/%s/%s" % (self.config["output_root"], self.config["env"]["name"], self.config["name"], self.config["save_model_path"])) self.log_path = util.create_directory( "%s/%s/%s/%s" % (self.config["output_root"], self.config["env"]["name"], self.config["name"], self.config["log_path"])) + "/%s.log" % self.learner_name # replay buffer to store data self.replay_buffer_lock = threading.RLock() self.replay_buffer = ReplayBuffer(self.learner_config["replay_size"], np.prod(self.env_config["obs_dims"]), self.env_config["action_dim"]) # data loaders pull data from the replay buffer and put it into the tfqueue for model usage self.data_loaders = self.make_loader_placeholders() queue_capacity = np.ceil( 1. / self.learner_config["frames_per_update"] ) if self.learner_config["frames_per_update"] else 100 self.tf_queue = tf.FIFOQueue( capacity=queue_capacity, dtypes=[dl.dtype for dl in self.data_loaders]) self.enqueue_op = self.tf_queue.enqueue(self.data_loaders) self.current_batch = self.tf_queue.dequeue() # build the TF graph for the actual model to train self.core, self.train_losses, self.train_ops, self.inspect_losses = self.make_core_model( ) self.sess = tf.Session() self.sess.run(tf.global_variables_initializer())
def compute_lqp(self, addcmd, options): """ Compute LQP Features, can be configured to run with different set of LQP types, coding types, tolerance, codebook size etc. """ values = { 'feature_type':14, 'cb_distance':0, 'ncluster_rounds':10, 'code_prune_count':10, 'lqp_stride':1, 'norm':1, 'patch_type':options.lqptype, 'code_type':options.coding} cmd = string.Template(" --FeatureType=${feature_type} --PatchType=${patch_type} "\ " --CodeBook-DMetric=${cb_distance} --ClusteringRounds=${ncluster_rounds} "\ "--Patch-PruneCount=${code_prune_count} --Patch-PatchStride=${lqp_stride} "\ " --Patch-CodingType=${code_type} --Normalization=${norm} ") cmd = addcmd + cmd.safe_substitute(values) lqpsize = u.check_islist(options.lqpsize) cbsize = u.check_islist(options.cbsize) tolerance = u.check_islist(options.tol) featdir = options.featdir count = 1 for tol in tolerance: for lqps in lqpsize: for cbs in cbsize: os.chdir(featdir) dirname = 'lqp-size=' + str(lqps) + '-codebooksize=' + str(cbs) + '-tolerance=' + str(tol) dirname = os.path.join(featdir, dirname) if not os.path.exists(dirname): print 'Making Directory =', dirname u.create_directory(dirname) self.dirs.append(dirname) os.chdir(dirname) values = {'tol':tol, 'cbsize':cbs, 'patch_size':lqps} addcmd = string.Template(" --LTP-Tolerance=${tol} --CodeBookSize=${cbsize} --Patch-PatchSize=${patch_size} ") addcmd = cmd + addcmd.safe_substitute(values) print "Running Process Number = ", count count = count + 1 self.compute_features(addcmd)
def compute_localpattern(self, addcmd, options): """ Function is used to compute Local Pattern (LBP, LTP, Features: """ features = {"LBP":1, "LTP":2, "LBP+LTP":3} values = {'feature_type': features[self.ftype], 'norm':1} cmd = string.Template(" --FeatureType=${feature_type} --Normalization=${norm} ") cmd = addcmd + cmd.safe_substitute(values) tolerance = u.check_islist(options.tol) # used only for ltp and lbp+ltp features, lbp features ignores this options count = 1 if self.ftype.upper() != "LBP": for tol in tolerance: os.chdir(self.featdir) dirname = self.ftype + '-tolerance=' + str(tol) dirname = os.path.join(self.featdir, dirname) if not os.path.exists(dirname): print 'Making Directory =', dirname u.create_directory(dirname) self.dirs.append(dirname) os.chdir(dirname) values = {'tol':tol} addcmd = string.Template(" --LTP-Tolerance=${tol} ") addcmd = cmd + addcmd.safe_substitute(values) print "Running Process Number = ", count count = count + 1 self.compute_features(addcmd) else: os.chdir(self.featdir) dirname = self.ftype dirname = os.path.join(self.featdir, dirname) if not os.path.exists(dirname): print 'Making Directory =', dirname u.create_directory(dirname) self.dirs.append(dirname) os.chdir(dirname) self.compute_features(cmd)
def __init__(self, thread_index=0, game=None, model_savefile=None, network_class="ACLstmNet", global_steps_counter=None, scenario_tag=None, run_id_string=None, session=None, tf_logdir=None, global_network=None, optimizer=None, learning_rate=None, test_only=False, test_interval=1, write_summaries=True, enable_progress_bar=True, deterministic_testing=True, save_interval=1, writer_max_queue=10, writer_flush_secs=120, gamma_compensation=False, figar_gamma=False, gamma=0.99, show_heatmaps=True, **settings): super(A3CLearner, self).__init__() log("Creating actor-learner #{}.".format(thread_index)) self.thread_index = thread_index self._global_steps_counter = global_steps_counter self.write_summaries = write_summaries self.save_interval = save_interval self.enable_progress_bar = enable_progress_bar self._model_savefile = None self._train_writer = None self._test_writer = None self._summaries = None self._session = session self.deterministic_testing = deterministic_testing self.local_steps = 0 # TODO epoch as tf variable? self._epoch = 1 self.train_scores = [] self.train_actions = [] self.train_frameskips = [] self.show_heatmaps = show_heatmaps self.test_interval = test_interval self.local_steps_per_epoch = settings["local_steps_per_epoch"] self._run_tests = settings["test_episodes_per_epoch"] > 0 and settings["run_tests"] self.test_episodes_per_epoch = settings["test_episodes_per_epoch"] self._epochs = np.float32(settings["epochs"]) self.max_remembered_steps = settings["max_remembered_steps"] assert not (gamma_compensation and figar_gamma) gamma = np.float32(gamma) if gamma_compensation: self.scale_gamma = lambda fskip: ((1 - gamma ** fskip) / (1 - gamma), gamma ** fskip) elif figar_gamma: self.scale_gamma = lambda fskip: (1.0, gamma ** fskip) else: self.scale_gamma = lambda _: (1.0, gamma) if self.write_summaries and thread_index == 0 and not test_only: assert tf_logdir is not None self.run_id_string = run_id_string self.tf_models_path = settings["models_path"] create_directory(tf_logdir) if self.tf_models_path is not None: create_directory(self.tf_models_path) if game is None: self.doom_wrapper = VizdoomWrapper(**settings) else: self.doom_wrapper = game misc_len = self.doom_wrapper.misc_len img_shape = self.doom_wrapper.img_shape self.use_misc = self.doom_wrapper.use_misc self.actions_num = self.doom_wrapper.actions_num self.local_network = getattr(networks, network_class)(actions_num=self.actions_num, img_shape=img_shape, misc_len=misc_len, thread=thread_index, **settings) if not test_only: self.learning_rate = learning_rate # TODO check gate_gradients != Optimizer.GATE_OP grads_and_vars = optimizer.compute_gradients(self.local_network.ops.loss, var_list=self.local_network.get_params()) grads, local_vars = zip(*grads_and_vars) grads_and_global_vars = zip(grads, global_network.get_params()) self.train_op = optimizer.apply_gradients(grads_and_global_vars, global_step=tf.train.get_global_step()) self.global_network = global_network self.local_network.prepare_sync_op(global_network) if self.thread_index == 0 and not test_only: self._model_savefile = model_savefile if self.write_summaries: self.actions_placeholder = tf.placeholder(tf.int32, None) self.frameskips_placeholder = tf.placeholder(tf.int32, None) self.scores_placeholder, summaries = setup_vector_summaries(scenario_tag + "/scores") # TODO remove scenario_tag from histograms a_histogram = tf.summary.histogram(scenario_tag + "/actions", self.actions_placeholder) fs_histogram = tf.summary.histogram(scenario_tag + "/frameskips", self.frameskips_placeholder) score_histogram = tf.summary.histogram(scenario_tag + "/scores", self.scores_placeholder) lr_summary = tf.summary.scalar(scenario_tag + "/learning_rate", self.learning_rate) summaries.append(lr_summary) summaries.append(a_histogram) summaries.append(fs_histogram) summaries.append(score_histogram) self._summaries = tf.summary.merge(summaries) self._train_writer = tf.summary.FileWriter("{}/{}/{}".format(tf_logdir, self.run_id_string, "train"), flush_secs=writer_flush_secs, max_queue=writer_max_queue) self._test_writer = tf.summary.FileWriter("{}/{}/{}".format(tf_logdir, self.run_id_string, "test"), flush_secs=writer_flush_secs, max_queue=writer_max_queue)
# See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== import numpy as np import tensorflow as tf # import moviepy.editor as mpy import time, os, traceback, multiprocessing, portalocker, sys import envwrap import util import valuerl, worldmodel from config import config MODEL_NAME = config["name"] LOG_PATH = util.create_directory("output/" + config["env"] + "/" + MODEL_NAME + "/" + config["log_path"]) + "/" + MODEL_NAME LOAD_PATH = util.create_directory("output/" + config["env"] + "/" + MODEL_NAME + "/" + config["save_model_path"]) OBS_DIM = np.prod(config["obs_dims"]) HIDDEN_DIM = config["hidden_dim"] ACTION_DIM = config["action_dim"] MAX_FRAMES = config["max_frames"] REWARD_SCALE = config["reward_scale"] DISCOUNT = config["discount"] ALGO = config["policy_config"]["algo"] AGENT_BATCH_SIZE = config["agent_config"]["batch_size"] EVALUATOR_BATCH_SIZE = config["evaluator_config"]["batch_size"] RELOAD_EVERY_N = config["agent_config"]["reload_every_n"] FRAMES_BEFORE_LEARNING = config["policy_config"]["frames_before_learning"] FRAMES_PER_UPDATE = config["policy_config"]["frames_per_update"] LEARNER_EPOCH_N = config["policy_config"]["epoch_n"]
def predict(self): try: if not util.check_valid_path(self.en_input_file.get()): messagebox.showwarning("Warning", "Your input image is invalid.") elif not util.check_valid_path(self.en_model_file.get()): messagebox.showwarning("Warning", "Your input model is invalid.") elif util.check_valid_path( self.en_input_file.get()) and util.check_valid_path( self.en_model_file.get()): # load label print("[INFO]: LOADING LABEL...") self.__label_data = pd.read_csv(cons.SIGNNAMES) self.__label_values = self.__label_data['SignName'].values print("[INFO]: FINISH LOADING LABEL.") # load Model print("[INFO]: LOADING MODEL...") self.__model = load_model(self.en_model_file.get()) print("[INFO]: FINISH LOADING MODEL.") # PREDICT PROCESS print("[INFO]: PREDICTING IMAGE...") img = cv2.imread(self.en_input_file.get()) # get ROI values in Test.csv y_test = pd.read_csv("./input/Test.csv") x1_val = y_test['Roi.X1'].values y1_val = y_test['Roi.Y1'].values x2_val = y_test['Roi.X2'].values y2_val = y_test['Roi.Y2'].values if self.__is_test_set_img: try: img_bbx = img.copy() x1, y1, x2, y2 = util.get_roi(self.en_input_file.get(), x1_val, y1_val, x2_val, y2_val) proposal = img[y1:y2, x1:x2] result = util.recognize_sign([proposal], self.__model)[0] sign_name = util.load_name(result, self.__label_values) if len(sign_name) > 0: # wm = plt.get_current_fig_manager() # wm.window.showMaximized() plt.imshow(cv2.cvtColor(img_bbx, cv2.COLOR_BGR2RGB)) plt.axis("off") plt.title("Result of prediction: " + sign_name) plt.show() else: messagebox.showinfo( "Infomation", "Sorry. Can not recognize any traffic sign in this image." ) except Exception as ex: print(ex) messagebox.showinfo( "Infomation", "Sorry. Can not recognize any traffic sign in this image." ) else: # convert Image to Binary Image img_bbx = img.copy() rows, cols, _ = img.shape img_bin = util.preprocess_img(img, False) # localize Traffic Sign (find Contours and draw to Image) min_area = img_bin.shape[0] * img.shape[1] / (25 * 25) rects = util.detect_contour(img_bin, min_area=min_area) img_rects = util.draw_rects_on_img(img, rects) sign_names = [] sep = ', ' # recognize Traffic sign for rect in rects: xc = int(rect[0] + rect[2] / 2) yc = int(rect[1] + rect[3] / 2) size = max(rect[2], rect[3]) x1 = max(0, int(xc - size / 2)) y1 = max(0, int(yc - size / 2)) x2 = min(cols, int(xc + size / 2)) y2 = min(rows, int(yc + size / 2)) proposal = img[y1:y2, x1:x2] result = util.recognize_sign([proposal], self.__model)[0] cv2.rectangle(img_bbx, (rect[0], rect[1]), (rect[0] + rect[2], rect[1] + rect[3]), (0, 0, 255), 2) cv2.putText(img_bbx, str(result), (rect[0], rect[1]), 1, 1.5, (0, 0, 255), 2) cv2.putText( img_bbx, util.load_name(result, self.__label_values), (rect[0], rect[1] + rect[3] + 20), 1, 1.5, (0, 0, 255), 2) sign_names.append( util.load_name(result, self.__label_values)) if len(sign_names) > 0: sep_res = sep.join(sign_names).replace('/', '-') time = datetime.now().strftime("%Y-%m-%d %Hh-%Mm-%Ss") dir_path = cons.RESULT_PATH + time util.create_directory(dir_path) res_path = dir_path + '\\{}_' + sep_res.replace( ',', '-') + '.jpg' cv2.imwrite(res_path.format("BIN_IMAGE"), img_bin) print("[INFO]: Saved binary image to " + res_path.format("BIN_IMAGE")) cv2.imwrite(res_path.format("RECTS_IMAGE"), img_rects) print("[INFO]: Saved rects image to " + res_path.format("RECTS_IMAGE")) cv2.imwrite(res_path.format("PREDICTED_IMAGE"), img_bbx) print("[INFO]: Saved predicted image to " + res_path.format("PREDICTED_IMAGE")) # wm = plt.get_current_fig_manager() # wm.window.showMaximized() plt.imshow(cv2.cvtColor(img_bbx, cv2.COLOR_BGR2RGB)) plt.axis("off") plt.title("Result of prediction: " + sep_res) plt.show() messagebox.showinfo( "Infomation", "Finish. Your result is saved in {}\\".format( dir_path)) else: messagebox.showinfo( "Infomation", "Sorry. Can not recognize any traffic sign in this image." ) print("[INFO]: FINISH PREDICTING IMAGE.") except Exception as ex: print(ex) messagebox.showerror("Error", "Error occurred while predicting image!")
def print_sep(sep="-", width=100): print(sep * width) return if __name__ == "__main__": try: terminal_columns, terminal_rows = os.get_terminal_size(0) except: terminal_columns = 100 params = vars(args) print("PARAMETERS:", params) create_directory("../results/") output_sufix_formatter = "_{}_sent_{}_ep_{}" print() if params["model"] not in ['BOTH', 'SP', 'RNN']: print("Invalid Model!") if params["model"] in ['BOTH', 'SP']: print_sep(width=terminal_columns) print("Starting SP:") print_sep(width=terminal_columns) params["output_sufix"] = output_sufix_formatter.format( "SP", params["number_sentences"], params["number_epochs"]) import sp sp.main(params) print_sep(width=terminal_columns)
def do_simulations(): delete_directory("./results") create_directory("./results") for index in file_indexes: print("#################### PROCESSING SCENARIO " + str(index) + " #########################") path_files = "./results/scenario-" + str(index) create_directory(path_files) print("#### Reading labbeled file: " + list_labelled_files[index]) df = read_labelled_file(list_labelled_files[index]) print("#### Generating baseline labbeled file: " + list_labelled_files[index]) baseline_bot = generate_botnet_baseline(df) num_bot_5tflows = len(baseline_bot["bot-5-tuples"]) print("#### Reading pcap's csv file: " + list_frompcap_files[index]) df = read_pcap_file(list_frompcap_files[index]) #baseline_hh = {} print("#### Generating baseline pcap's csv file: " + list_labelled_files[index]) for time_window in array_time_window: out_file_hh = csv.writer(open( path_files + "/hh_stats_f" + str(index) + "_w" + str(time_window) + ".csv", "wb"), delimiter=';', quoting=csv.QUOTE_ALL) columns = [ "index_chunk", "bound", "total_num_flows", "total_num_hh_flows", "total_num_5tflows", "total_num_hh_5tflows", "pkts_to_start_hhtests", "TP", "TN", "FP", "FN", "TPR (Recall)", "TNR", "FPR", "FNR", "Precision", "Accuracy", "F1_Score" ] out_file_hh.writerow(columns) out_file_bot = csv.writer(open( path_files + "/bot_stats_f" + str(index) + "_w" + str(time_window) + ".csv", "wb"), delimiter=';', quoting=csv.QUOTE_ALL) columns = [ "bound", "total_num_bot_5tflows", "pkts_to_start_hhtests", "TP", "FN", "TPR (Recall)" ] out_file_bot.writerow(columns) time = str(time_window) + 's' chunks = df.groupby(pd.Grouper(freq=time)) index_chunk = 1 results_bot_5tflows = {} for name, c in chunks: for bound in array_bound: print "### Time Window: " + str( time_window) + " - Time Slot: " + str( index_chunk) + " - Bound: " + str(bound) if str(bound) not in results_bot_5tflows: results_bot_5tflows[str(bound)] = {} baseline_hh = generate_baseline(c, bound) data = [ index_chunk, bound, len(baseline_hh["packets"]) + len(baseline_hh["tn_packets"]), len(baseline_hh["packets"]), len(baseline_hh["5t_packets"]) + len(baseline_hh["5t_tn_packets"]), len(baseline_hh["5t_packets"]) ] data_pkts_to_start = [[]] data_hh_stats = [[], [], [], [], [], [], [], [], [], [], []] for pkts_to_start in array_pkts_to_start: print "## Packets to Start HH Tests: " + str( pkts_to_start) if str(pkts_to_start) not in results_bot_5tflows[str( bound)]: results_bot_5tflows[str(bound)][str( pkts_to_start)] = set() data_pkts_to_start[0].append(pkts_to_start) results = simulate_rtp4mon(c, bound, pkts_to_start) results_bot_5tflows[str(bound)][str( pkts_to_start)] = results_bot_5tflows[str(bound)][ str(pkts_to_start)] | results["5t_packets"] hh_stats = generate_hh_stats(baseline_hh, results) for i in range(0, len(data_hh_stats)): data_hh_stats[i].append(hh_stats[i]) data = data + data_pkts_to_start + data_hh_stats out_file_hh.writerow(data) index_chunk += 1 for bound in array_bound: data_pkts_to_start = [[]] data_bot_stats = [[], [], []] data = [bound, num_bot_5tflows] for pkts_to_start in array_pkts_to_start: data_pkts_to_start[0].append(pkts_to_start) bot_stats = generate_bot_stats( baseline_bot, results_bot_5tflows[str(bound)][str(pkts_to_start)]) for i in range(0, len(data_bot_stats)): data_bot_stats[i].append(bot_stats[i]) data = data + data_pkts_to_start + data_bot_stats out_file_bot.writerow(data)
def __init__(self, scenario_tag=None, model_savefile=None, run_id_string=None, network_class="DQNNet", write_summaries=True, tf_logdir="tensorboard_logs", epochs=100, train_steps_per_epoch=1000000, test_episodes_per_epoch=100, run_tests=True, initial_epsilon=1.0, final_epsilon=0.0000, epsilon_decay_steps=10e07, epsilon_decay_start_step=2e05, frozen_steps=5000, batchsize=32, memory_capacity=10000, update_pattern=(4, 4), prioritized_memory=False, enable_progress_bar=True, save_interval=1, writer_max_queue=10, writer_flush_secs=120, dynamic_frameskips=None, **settings): if prioritized_memory: raise NotImplementedError( "Prioritized memory not implemented. Maybe some day.") # TODO maybe some day ... pass if dynamic_frameskips: if isinstance(dynamic_frameskips, (list, tuple)): self.frameskips = list(dynamic_frameskips) elif isinstance(dynamic_frameskips, int): self.frameskips = list(range(1, dynamic_frameskips + 1)) else: self.frameskips = [None] self.update_pattern = update_pattern self.write_summaries = write_summaries self._settings = settings self.run_id_string = run_id_string self.train_steps_per_epoch = train_steps_per_epoch self._run_tests = test_episodes_per_epoch > 0 and run_tests self.test_episodes_per_epoch = test_episodes_per_epoch self._epochs = np.float32(epochs) self.doom_wrapper = VizdoomWrapper(**settings) misc_len = self.doom_wrapper.misc_len img_shape = self.doom_wrapper.img_shape self.use_misc = self.doom_wrapper.use_misc self.actions_num = self.doom_wrapper.actions_num self.replay_memory = ReplayMemory(img_shape, misc_len, batch_size=batchsize, capacity=memory_capacity) self.network = getattr(networks, network_class)( actions_num=self.actions_num * len(self.frameskips), img_shape=img_shape, misc_len=misc_len, **settings) self.batchsize = batchsize self.frozen_steps = frozen_steps self.save_interval = save_interval self._model_savefile = model_savefile ## TODO move summaries somewhere so they are consistent between dqn and asyncs if self.write_summaries: assert tf_logdir is not None create_directory(tf_logdir) self.scores_placeholder, summaries = setup_vector_summaries( scenario_tag + "/scores") self._summaries = tf.summary.merge(summaries) self._train_writer = tf.summary.FileWriter( "{}/{}/{}".format(tf_logdir, self.run_id_string, "train"), flush_secs=writer_flush_secs, max_queue=writer_max_queue) self._test_writer = tf.summary.FileWriter( "{}/{}/{}".format(tf_logdir, self.run_id_string, "test"), flush_secs=writer_flush_secs, max_queue=writer_max_queue) else: self._train_writer = None self._test_writer = None self._summaries = None self.steps = 0 # TODO epoch as tf variable? self._epoch = 1 # Epsilon self.epsilon_decay_rate = (initial_epsilon - final_epsilon) / epsilon_decay_steps self.epsilon_decay_start_step = epsilon_decay_start_step self.initial_epsilon = initial_epsilon self.final_epsilon = final_epsilon self.enable_progress_bar = enable_progress_bar
def run(self, src, dest): print src, dest if (not os.path.exists(src)): raise Exception("Source path not valid: %s" % (src)) elif (not os.path.exists(dest)): raise Exception("Destination path not valid: %s" % (dest)) src = os.path.normpath(src) dest = os.path.normpath(dest) if (dest.find(src) == 0): raise Exception("Destination must not be inside Source path.") history = {} w = os.walk(src) for root, dirs, files in w: print root for f in files: fullpath = os.path.join(root, f) if self.time_type == MTIME: t = os.path.getmtime(fullpath) elif self.time_type == CTIME: t = os.path.getctime(fullpath) elif self.time_type == ATIME: t = os.path.getatime(fullpath) else: raise Exception("time_type is not one of MTIME, CTIME, ATIME.") ts = time.localtime(t) if self.keep_directory: subfolder = root[len(src)+1:] outdir = os.path.join(dest, subfolder, self.get_outdir(ts)) else: outdir = os.path.join(dest, self.get_outdir(ts)) outfile = os.path.join(outdir, f) if outfile not in history and not os.path.exists(outfile): version = 0 else: name = f ext = '' if name.rfind('.') > 0: # Has ext and not .something. (name, ext) = name.rsplit('.', 1) ext = '.' + ext if outfile not in history: # Attempt to see if the file aleady ends in a number in # _### format. if name.rfind('_') != -1: (tname, tver) = name.rsplit('_', 1) try: version = int(tver) name = tname except ValueError: version = 1 else: version = 1 else: version = history[outfile] # Put the versioned filename back together. fn = name + '_' + str(version) + ext outfile = os.path.join(outdir, fn) # Unlikely, but just in case of bizarre conflicts. while os.path.exists(outfile): version += 1 fn = name + '_' + str(version) + ext outfile = os.path.join(outdir, fn) history[outfile] = version + 1 print "in: %s, out: %s" % (fullpath, outfile) # Actually copy/move the file. if not os.path.exists(outdir): util.create_directory(outdir) if self.op_type == MOVE: shutil.move(fullpath, outfile) else: shutil.copy2(fullpath, outfile) if not self.recurse: break
# See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== import numpy as np import tensorflow as tf # import moviepy.editor as mpy import time, os, traceback, multiprocessing, portalocker, sys import envwrap import util import valuerl, worldmodel from config import config MODEL_NAME = config["name"] LOG_PATH = util.create_directory("output/" + config["env"] + "/" + MODEL_NAME + "/" + config["log_path"]) + "/" + MODEL_NAME LOAD_PATH = util.create_directory("output/" + config["env"] + "/" + MODEL_NAME + "/" + config["save_model_path"]) OBS_DIM = np.prod(config["obs_dims"]) HIDDEN_DIM = config["hidden_dim"] ACTION_DIM = config["action_dim"] MAX_FRAMES = config["max_frames"] REWARD_SCALE = config["reward_scale"] DISCOUNT = config["discount"] ALGO = config["policy_config"]["algo"] AGENT_BATCH_SIZE = config["agent_config"]["batch_size"] EVALUATOR_BATCH_SIZE = config["evaluator_config"]["batch_size"] RELOAD_EVERY_N = config["agent_config"]["reload_every_n"] FRAMES_BEFORE_LEARNING = config["policy_config"]["frames_before_learning"] FRAMES_PER_UPDATE = config["policy_config"]["frames_per_update"] LEARNER_EPOCH_N = config["policy_config"]["epoch_n"] SYNC_UPDATES = config["policy_config"]["frames_per_update"] >= 0
def log_config(): HPS_PATH = util.create_directory("output/" + config["env"]["name"] + "/" + config["name"] + "/" + config["log_path"]) + "/hps.json" print("ROOT GPU: " + str(args.root_gpu) + "\n" + str(cstr)) with open(HPS_PATH, "w") as f: f.write("ROOT GPU: " + str(args.root_gpu) + "\n" + str(cstr))