def run(self): total_step = 1 while self.global_episode_counter.value < self.max_episode: s = self.env.reset() buffer_s, buffer_a, buffer_r = [], [], [] episode_reward = 0 while True: if self.name == 'w0': self.env.render() a = self.local_net.choose_action( torch.Tensor(s).view(-1, self.observation_d)) s_, r, done, _ = self.env.step(a) if done: r = -1 episode_reward += r buffer_a.append(a) buffer_r.append(r) buffer_s.append(s) if total_step % self.update_global_iteration == 0 or done: # sync pull_and_push(self.optimizer, self.local_net, self.global_net, done, s_, buffer_s, buffer_a, buffer_r, self.gamma) buffer_s, buffer_a, buffer_r = [], [], [] if done: # record record(self.global_episode_counter, self.global_reward, episode_reward, self.res_queue, self.name) break s = s_ total_step += 1 self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < self.args.MAXEPS: # print(self.g_ep.value) s = self.env.reset() buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0 for t in range(self.args.MAXSTEP): if self.name == 'worker0': self.env.render() a = self.lnet.choose_action(v_wrap(s[None, :])) s_, r, done, _ = self.env.step(a.clip(-2, 2)) if t == self.args.MAXSTEP - 1: done = True ep_r += r buffer_s.append(s) buffer_a.append(a) buffer_r.append((r + 8.1) / 8.1) if total_step % self.args.updateperiod == 0 or done: # print(total_step) push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, self.args.gamma) buffer_s, buffer_a, buffer_r = [], [], [] if done: print('*') record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ total_step += 1 self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: s = self.env.reset() buffer_s, buffer_action, buffer_reward = [], [], [] ep_r = 0. while True: if self.name == 'w00': self.env.render() a = self.lnet.choose_action(v_wrap(s[None, :])) s_, r, done, _ = self.env.step(a) if done: r = -1 ep_r += r buffer_action.append(a) buffer_s.append(s) buffer_reward.append(r) if total_step % UPDATE_GLOBAL_ITER == 0 or done: # update global and assign to local net # sync push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_action, buffer_reward, GAMMA) buffer_s, buffer_action, buffer_reward = [], [], [] if done: # done and print information record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ total_step += 1 self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: s = self.env.reset() buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0. while True: if self.name == 'w00': self.env.render() a = self.lnet.choose_action(v_wrap(s[None, :])) s_, r, done, _ = self.env.step(a) if done: r = -1 ep_r += r buffer_a.append(a) buffer_s.append(s) buffer_r.append(r) if total_step % UPDATE_GLOBAL_ITER == 0 or done: push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ total_step += 1 self.res_queue.put(None)
def run(self): total_step = 1 while self.global_episode_counter.value < self.max_episode: obs = self.env.reset() obs = img_process(obs, self.observation_dim[1:]) episode_reward = 0 while True: if self.name == 'w0': self.env.render() action = self.local_net.act( torch.FloatTensor(np.expand_dims(obs, 0)), self.last_action, self.last_reward) next_obs, reward, done, _ = self.env.step(action) next_obs = img_process(next_obs, self.observation_dim[1:]) self.last_action = torch.FloatTensor( one_hot_numpy(self.action_dim, [action])) self.last_reward = torch.FloatTensor([reward]).unsqueeze(0) self.buffer.store(obs, action, reward, next_obs, done) obs = next_obs episode_reward += reward if total_step % self.train_freq == 0 or done: pull_and_push(self.optimizer, self.local_net, self.global_net, self.buffer, self.action_dim, self.batch_size, self.pc_weight, self.rp_weight, self.vr_weight) self.buffer.clear_main() if done: record(self.global_episode_counter, self.global_reward, episode_reward, self.res_queue, self.name) break total_step += 1 self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: s = self.env.reset() buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0. for t in range(MAX_EP_STEP): if self.name == 'w0': self.env.render() a = self.lnet.choose_action(v_wrap(s[None, :])) s_, r, done, _ = self.env.step(a.clip(-2, 2)) if t == MAX_EP_STEP - 1: done = True ep_r += r buffer_a.append(a) buffer_s.append(s) buffer_r.append((r + 8.1) / 8.1) # normalize if total_step % UPDATE_GLOBAL_ITER == 0 or done: # update global and assign to local net # sync push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ total_step += 1 self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: # restarts the game s = step(0, 1, self.port)[0] # updates the video frame for matplotlib self.frame.refresh_plot(s) #print("img_array", s) s = feature_vec(s) # feature_vec buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0.0 while True: # have the model make a decision a = self.lnet.choose_action(s) # drive the vehicle s_, r, done = step(a, 0, self.port) # updates the video frame for matplotlib self.frame.refresh_plot(s_) s_ = feature_vec(s) # -1 is one char longer than 1 or 0, so adding a space to 1 and 0 in order to avoid having shaky text if a - 1 == -1: print( "{}, action = {}, reward = {}, episode reward = {}, restart = {}" .format(self.name, a - 1, round(r, 2), round(ep_r, 2), done)) else: print( "{}, action = {}, reward = {}, episode reward = {}, restart = {}" .format(self.name, a - 1, round(r, 2), round(ep_r, 2), done)) ep_r += r buffer_a.append(a) buffer_s.append(s) buffer_r.append(r) # update global and assign to local net if total_step % UPDATE_GLOBAL_ITER == 0 or done: # sync push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ total_step += 1 self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: try: mapID = np.random.randint( 1, 6) #Choosing a map ID from 5 maps in Maps folder randomly posID_x = np.random.randint( MAP_MAX_X ) #Choosing a initial position of the DQN agent on X-axes randomly posID_y = np.random.randint( MAP_MAX_Y ) #Choosing a initial position of the DQN agent on Y-axes randomly #Creating a request for initializing a map, initial position, the initial energy, and the maximum number of steps of the DQN agent request = ("map" + str(mapID) + "," + str(posID_x) + "," + str(posID_y) + ",50,100") #Send the request to the game environment (GAME_SOCKET_DUMMY.py) self.env.send_map_info(request) self.env.reset() s = self.env.get_state() print(s.shape) buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0. for t in range(MAX_EP_STEP): a = self.lnet.choose_action(v_wrap(s[None, :]), .5) self.env.step(str(a)) s_ = self.env.get_state() r = self.env.get_reward() done = self.env.check_terminate() if t == MAX_EP_STEP - 1: done = True ep_r += r buffer_a.append(a) buffer_s.append(s) buffer_r.append(r) if total_step % UPDATE_GLOBAL_ITER == 0 or done: # update global and assign to local net # sync push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ total_step += 1 except Exception as e: import traceback traceback.print_exc() break self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: s = reset() print("img_array", s) s = feature_vec(s) print("feat", s) # s = self.env.reset() # feature_vec buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0. while True: # if self.name == 'w0': # self.env.render() # feature_vec a = self.lnet.choose_action(s) # a = self.lnet.choose_action(v_wrap(s[None, :])) s_, r, done = step(a) # s_, r, done, _ = self.env.step(a) # feature_vec print("a", a) print("s_", s_) print("r", r) print("done", done) if done: r = -1 ep_r += r buffer_a.append(a) buffer_s.append(s) buffer_r.append(r) # update global and assign to local net if total_step % UPDATE_GLOBAL_ITER == 0 or done: # sync push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ total_step += 1 self.res_queue.put(None)
def run(qobj, device, parameters, comment="", monitor=False): job = device.run(qobj) path = utils.record(job, device, parameters, comment) if monitor: print(path) job_monitor(job) _ = job.result() return path
def save_record(model_index, epoch, optim, recon_loss, KLD_loss): record_data = dict() if epoch == 0: record_data["model_name"] = "fcn_model_{}.pkl".format(model_index) record_data["data_size"] = AVAILABLE_SIZE record_data["batch_size"] = BATCHSIZE record_data["decay"] = str((LR_STEPSIZE, LR_GAMMA)) record_data["lr_init"] = float(optim.param_groups[0]["lr"]) record_data["lr"] = float(optim.param_groups[0]["lr"]) record_data["record_epoch"] = RECORD_MODEL_PERIOD record_data["recon_loss"] = round(float(recon_loss.data), 6) record_data["KLD_loss"] = round(float(KLD_loss), 6) else: record_data["model_name"] = "fcn_model_{}.pkl".format(model_index) record_data["lr"] = float(optim.param_groups[0]["lr"]) record_data["recon_loss"] = round(float(recon_loss.data), 6) record_data["KLD_loss"] = round(float(KLD_loss), 6) record(RECORD_FP, record_data)
def main(_): tf.logging.info('Loading Graph...') model = CapsNet() tf.logging.info('Graph loaded') sv = tf.train.Supervisor(graph=model.graph, logdir=cfg.logdir, save_model_secs=0) if not cfg.is_training: #_ = evaluation(model, sv) _ = test(model, sv) else: tf.logging.info('Start is_training...') loss, acc = train(model, sv) tf.logging.info('Training done') if cfg.save: test_acc = evaluation(model, sv) record(loss, acc, test_acc)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: s = np.transpose(self.env.reset(), (2, 0, 1)) / 255.0 lives = self.lives_sum buffer_s, buffer_a, buffer_r = [], [], [] self.ep_r = 0. actions = [] while True: total_step += 1 self.env.render() a = self.lnet.choose_action(v_wrap(s[None, :])) # a = np.random.randint(low = 0, high = 8) actions.append(str(a)) s_, r, done, info = self.env.step(a) s_ = np.transpose(s_, (2, 0, 1)) / 255.0 livesLeft = info[ 'ale.lives'] # punish everytime the agent loses life if livesLeft != lives: r = DIE_PENALTY lives = livesLeft self.ep_r += r buffer_a.append(a) buffer_s.append(s) buffer_r.append(r) if total_step % UPDATE_GLOBAL_ITER == 0 or done: # update global and assign to local net # sync # if self.name == 'w0': # self.env.render() push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information record(self.g_ep, self.ep_r, self.res_queue, self.name, self.lives_sum, DIE_PENALTY) break s = s_ self.res_queue.put(None)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: ################################ # Initial State # ################################ a = np.array([100, 0]) s = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]).reshape( (1, N_S)).unsqueeze(0) real_state = np.array([]) ######################### buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0. for t in range(MAX_EP_STEP): a = self.lnet.choose_action(s) r, real_state_, s_ = self.env(a, real_state, t) r = np.expand_dims(np.expand_dims(r, 0), 0) s_ = s_.reshape((1, N_S)).unsqueeze(0).float() ep_r += r buffer_a.append(np.array(a)) buffer_s.append(s.squeeze().numpy()) buffer_r.append(r.squeeze()) done = False if t == MAX_EP_STEP - 1: done = True if total_step % UPDATE_GLOBAL_ITER == 0 or done: # update global and assign to local net # sync push_and_pull(self.opt, self.lnet, self.gnet, done, s_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break s = s_ real_state = real_state_ total_step += 1 self.res_queue.put(None)
def predict(sentence): global text_id text_id += 1 predict_line = {} predict_line['text_id'] = str(text_id) predict_line['text'] = sentence.replace('[', '').replace(']', '') predict_line['mention_data'] = [] it = re.finditer(patten, sentence) for i, match in enumerate(it): predict_line['mention_data'].append({ "mention": match.group()[1:-1], "offset": str(match.start() - 2 * i) }) jsonstr = json.dumps(predict_line, ensure_ascii=False) with open("./data/basic_data/predict.json", 'w', encoding='utf-8') as jsonfile: jsonfile.write(jsonstr) # 生成预测的文本数据 GeneratePairwaiseSample('predict.json', cand_dic, ent_dic, is_train=False) # 数据编码 data_encoder.data_encode("./data/generated/predict_data.txt", is_train=False) # 构建数据集加载接口 predict_set = DataSet("./data/generated/predict.csv", is_train=False) # dataloader test_loader = DATA.DataLoader(predict_set, batch_size=8, collate_fn=utils.collate_fn_test) result = {} for i, test_data in enumerate(test_loader): id_list, query, offset, cand_desc, seq_len = test_data # forward pre_label, pre_type = model.predict(query, offset, cand_desc, seq_len) # 记录预测结果 result = utils.record(result, id_list, torch.softmax(pre_label, dim=-1), pre_type) # 处理预测结果,生成打印信息 data = [] with open('./data/basic_data/predict.json', 'r', encoding='utf8') as f: for line in f.readlines(): data.append(json.loads(line)) for i, line in enumerate(data): res_line = result[line['text_id']] mention_data = line["mention_data"] for mid, item in enumerate(line["mention_data"]): item['pre_id'] = res_line[str(mid)]['pre_id'] pre_type_id = res_line[str(mid)]['pre_type'].argmax().item() item['pre_type'] = utils.lable2type[pre_type_id] if item['pre_id'] != 'NIL': item["pre_desc"] = ent_dic[item['pre_id']]['ent_desc'] item['pre_type'] = ent_dic[item['pre_id']]['type'] mention_data[mid] = item data[i]['mention_data'] = mention_data # 打印结果 f = open('./data/basic_data/predict_result.json', 'w+', encoding='utf8') for i in data: print(i['text']) for j in i['mention_data']: print("实体:\t", j['mention']) print("类型:\t", j['pre_type']) if j['pre_id'] != 'NIL': print('描述:\t', j['pre_desc']) print('\n') f.write(json.dumps(i, ensure_ascii=False) + '\n') f.close() return data
import tensorflow as tf import config from model import DS2 from utils import int_to_text_sequence, record, wav_to_mfcc from char_set import Char_set if __name__ == "__main__": #录音 record() #加载模型检查点 model = DS2() #加载检查点 checkpoint = tf.train.Checkpoint(model=model) manager = tf.train.CheckpointManager( checkpoint, directory=config.configs_checkpoint()['directory'], max_to_keep=config.configs_checkpoint()['max_to_keep']) if manager.latest_checkpoint: checkpoint.restore(manager.latest_checkpoint) audio_path = config.configs_record()["record_path"] x_test = wav_to_mfcc(config.configs_other()["n_mfcc"], audio_path) x_test_input = tf.expand_dims(x_test, axis=0) y_test_pred = model(x_test_input) output = tf.keras.backend.ctc_decode(y_pred=y_test_pred, input_length=tf.constant( [y_test_pred.shape[1]]), greedy=True) cs = Char_set(config.configs_other()["char_set_path"]) str = "".join(int_to_text_sequence(output[0][0].numpy()[0], cs))
def run(self): record(self.check_abort)
def run(self): total_step = 1 while self.g_ep.value < MAX_EP: # get video ----------------------------- while(True): video_random = random.random() videoName = "" for i in range(len(self.videoList)): if video_random < self.videoList[i][1]: videoName = self.videoList[i - 1][0] break if videoName == "": videoName = self.videoList[-1][0] else: break # get video ----------------------------- busyList = self.get_busyTrace() bandwidth_fileName, rtt = self.getBandwidthFile() reqBI = self.client.init(videoName, bandwidth_fileName, rtt, self.bwType) # mask--------------------------- mask = [1] * A_DIM randmCachedBICount = random.randint(1, 5) BI = [0,1,2,3,4] randomCachedBI = random.sample(BI, randmCachedBICount) for bIndex in range(5): if bIndex not in randomCachedBI: mask[bIndex] = 0 # mask--------------------------- segNum = 0 buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0. busy = busyList[segNum%len(busyList)] state_ = np.zeros(S_LEN) state = state_.copy() #state =[reqBitrate, lastBitrate, buffer, hThroughput, mThroughput, busy, mask] reqBitrate, lastBitrate, buffer, hThroughput, mThroughput, reward, reqBI, done, segNum, busy = [0] * 10 # start one epoch ********************************** while True: if sum(mask) == 1: a = mask.index(1) break # lnet.chose_action **************************** a, logits = self.lnet.choose_action(mask, v_wrap(state[None, :])) # lnet.choose_action **************************** # print -------------------------------------------- if platform.system() == "Linux": if random.randint(0,1000) == 1: print("reqb=", reqBitrate, "lb=", lastBitrate, "buffer=", int(buffer), "hT=", int(hThroughput), "mT=", int(mThroughput), "busy=", round(busy, 2), "mask=",mask, "action=", a, "reqBI=", reqBI, "reward=",round(reward,2), "logits=", logits) else: print("reqb=", reqBitrate, "lb=", round(lastBitrate,2), "buffer=", int(buffer), "hT=", int(hThroughput), "mT=", int(mThroughput), "busy=", round(busy, 2), "mask=",mask, "action=", a, "reqBI=", reqBI, "reward=",round(reward,2), "logits=", logits) # print -------------------------------------------- busy = busyList[segNum % len(busyList)] # client.run **************************** if a == 5: hitFlag = False else: hitFlag = True reqBitrate, lastBitrate, buffer, hThroughput, mThroughput, reward, reqBI, done, segNum = self.client.run(a, busy, hitFlag) # client.run **************************** state_[0] = reqBitrate / BITRATES[-1] state_[1] = lastBitrate / BITRATES[-1] state_[2] = (buffer/1000 - 30) / 10 state_[3] = (hThroughput - throughput_mean) / throughput_std state_[4] = (mThroughput - throughput_mean) / throughput_std print(state) # state_[5] = (busy - busy_mean) / busy_std reward = reward / 5 ep_r += reward buffer_a.append(a) buffer_s.append(state) buffer_r.append(reward) if total_step % UPDATE_GLOBAL_ITER == 0 or done: # update global and assign to local net # sync push_and_pull(self.opt, self.lnet, self.gnet, done, state_, buffer_s, buffer_a, buffer_r, GAMMA) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information record(self.g_ep, self.g_ep_r, ep_r, self.res_queue, self.name) break state = state_.copy() total_step += 1 self.res_queue.put(None) print("end run")
cols = st.beta_columns((1, 1, 1, 2)) record_btn = cols[0].button("Record") play_btn = cols[1].button("Play") classify_btn = cols[2].button("Classify") display_btn = cols[3].button("Display Melspectogram") for i in range(2): st.write(" ") slot = st.empty() if record_btn: with st.spinner("Recording for 3 seconds"): utils.record() st.success("Recording Completed") if play_btn: if os.path.exists(config.RECORDING_NPY): utils.play() else: slot.write("Please record sound first!!") if classify_btn: if os.path.exists(config.RECORDING_NPY): model = model.load_model() mel_tensor = utils.create_tensor() pred = model(mel_tensor) pred_value = torch.argmax(pred) chord_name = config.CHORDS_MAPPING[pred_value.item()]
def run(self): ptitle('Training Agent: {}'.format(self.rank)) config = self.config check_point_episodes = config["check_point_episodes"] check_point_folder = os.path.join(config["check_point_folder"], config["env"]) setup_worker_logging(self.log_queue) self.env = create_env(config["env"], self.seed) observation_space = self.env.observation_space action_space = IdToAct(self.env.action_space) with open(os.path.join("data", f"{config['env']}_action_space.npz"), 'rb') as f: archive = np.load(f) action_space.init_converter(all_actions=archive[archive.files[0]]) self.action_space = action_space all_actions = np.array(action_space.all_actions) self.local_net = Net(self.state_size, self.action_mappings, self.action_line_mappings) # local network self.local_net = cuda(self.gpu_id, self.local_net) total_step = 1 l_ep = 0 while self.g_ep.value < self.num_episodes: self.print( f"{self.env.name} - {self.env.chronics_handler.get_name()}") if isinstance(self.env, MultiMixEnvironment): obs = self.env.reset(random=True) else: obs = self.env.reset() maintenance_list = obs.time_next_maintenance + obs.duration_next_maintenance s = self.convert_obs(observation_space, obs) s = v_wrap(s[None, :]) s = cuda(self.gpu_id, s) buffer_s, buffer_a, buffer_r = [], [], [] ep_r = 0. ep_step = 0 ep_agent_num_dmd = 0 ep_agent_num_acts = 0 while True: rho = obs.rho.copy() rho[rho == 0.0] = 1.0 lines_overload = rho > config["danger_threshold"] expert_act = expert_rules(self.name, maintenance_list, ep_step, action_space, obs) if expert_act is not None: a = np.where(all_actions == expert_act)[0][0] choosen_actions = np.array([a]) #print(f"Expert act: {a}") elif not np.any(lines_overload): choosen_actions = np.array([0]) else: lines_overload = cuda( self.gpu_id, torch.tensor(lines_overload.astype(int)).float()) attention = torch.matmul(lines_overload.reshape(1, -1), self.action_line_mappings) attention[attention > 1] = 1 choosen_actions = self.local_net.choose_action( s, attention, self.g_num_candidate_acts.value) ep_agent_num_dmd += 1 obs_previous = obs a, obs_forecasted, obs_do_nothing = forecast_actions( choosen_actions, self.action_space, obs, min_threshold=0.95) logging.info(f"{self.name}_act|||{a}") act = self.action_space.convert_act(a) obs, r, done, info = self.env.step(act) r = lreward(a, self.env, obs_previous, obs_do_nothing, obs_forecasted, obs, done, info, threshold_safe=0.85) if a > 0: if r > 0: print("+", end="") elif r < 0: print("-", end="") elif len(choosen_actions) > 0: print("*", end="") else: print("x", end="") else: if len(choosen_actions) > 0: print("o", end="") else: print("0", end="") if r > 0: ep_agent_num_acts += 1 s_ = self.convert_obs(observation_space, obs) s_ = v_wrap(s_[None, :]) s_ = cuda(self.gpu_id, s_) ep_r += r buffer_a.append(a) buffer_s.append(s) buffer_r.append(r) if total_step % self.update_global_iter == 0 or done: # update global and assign to local net # sync # if len(buffer_r) > 0 and np.mean(np.abs(buffer_r)) > 0: buffer_a = cuda(self.gpu_id, torch.tensor(buffer_a, dtype=torch.long)) buffer_s = cuda(self.gpu_id, torch.cat(buffer_s)) push_and_pull(self.opt, self.local_net, check_point_episodes, check_point_folder, self.g_ep, l_ep, self.name, self.rank, self.global_net, done, s_, buffer_s, buffer_a, buffer_r, self.gamma, self.gpu_id) buffer_s, buffer_a, buffer_r = [], [], [] if done: # done and print information print("") record(config["starting_num_candidate_acts"], config["num_candidate_acts_decay_iter"], self.g_ep, self.g_step, self.g_num_candidate_acts, self.g_ep_r, ep_r, self.res_queue, self.name, ep_step, ep_agent_num_dmd, ep_agent_num_acts) break s = s_ total_step += 1 ep_step += 1 l_ep += 1 self.res_queue.put(None)
cand2_desc = cand2_desc.to(device) label = label.to(device) ent_type = ent_type.to(device) # forward pre_label, pre_type = model.forward(query, offset, cand1_desc, cand2_desc, seq_len) # loss rank_loss = rank_loss_fn(pre_label, label) type_loss = classify_loss_fn(pre_type, ent_type) loss = rank_loss * param["loss_w"] + type_loss * (1 - param["loss_w"]) # optimization optimizer.zero_grad() loss.backward() optimizer.step() train_res = utils.record(train_res, id_list, torch.softmax(pre_label, dim=-1), pre_type, label) if i % 1000 == 0: print('Epoch [{}/{}], Step [{}/{}]'.format(epoch, param["epoch"], i, total_step)) print("Loss: ", loss.item(), "rank_loss: ", rank_loss.item(), "type_loss: ", type_loss.item()) accuracy = utils.Accuracy(train_res) train_accuracy.append(accuracy) print("train accuracy: ", accuracy) dev_res = {} # evalue with torch.no_grad(): for i, data in enumerate(dev_loader): id_list, query, offset, cand_desc, seq_len = data
elif args.test == True: deltapeak = stim.test_deconvolution(args) plt.plot(deltapeak) plt.show() else: # Create a test signal object, and generate the excitation testStimulus = stim.stimulus('sinesweep', args.fs) testStimulus.generate(args.fs, args.duration, args.amplitude, args.reps, args.startsilence, args.endsilence, args.sweeprange) # Record recorded = utils.record(testStimulus.signal, args.fs, args.inputChannelMap, args.outputChannelMap) # Deconvolve RIR = testStimulus.deconvolve(recorded) # Truncate lenRIR = 1.2 startId = testStimulus.signal.shape[0] - args.endsilence * args.fs - 1 endId = startId + int(lenRIR * args.fs) # save some more samples before linear part to check for nonlinearities startIdToSave = startId - int(args.fs / 2) RIRtoSave = RIR[startIdToSave:endId, :] RIR = RIR[startId:endId, :] # Save recordings and RIRs utils.saverecording(RIR, RIRtoSave, testStimulus.signal, recorded,
def train(data_loader, model_index, x_eval_train, y_eval_train): ### Model Initiation fcn = FCN() #print (fcn.b_1_conv_1[0].weight.data) d = tor.load("./models/vgg16_pretrained.pkl") fcn.vgg16_load(d) #d = tor.load("./models/fcn_model_1_1.pkl") #fcn.load_state_dict(d) fcn.cuda() #loss_func = tor.nn.CrossEntropyLoss(weight=w) loss_func = tor.nn.CrossEntropyLoss() #loss_func = tor.nn.MSELoss() #optim = tor.optim.SGD(fcn.parameters(), lr=LR, momentum=MOMENTUM) optim1 = tor.optim.Adam(fcn.b_6_conv_1.parameters(), lr=LR) optim2 = tor.optim.Adam(fcn.b_6_conv_2.parameters(), lr=LR) optim3 = tor.optim.Adam(fcn.b_6_conv_3.parameters(), lr=LR) optim4 = tor.optim.Adam(fcn.b_7_trans_1.parameters(), lr=LR) optim = tor.optim.Adam(fcn.parameters(), lr=LR) ### Training for epoch in range(EPOCH): print("|Epoch: {:>4} |".format(epoch + 1), end="") ### Training for step, (x_batch, y_batch) in enumerate(data_loader): x = Variable(x_batch).type(tor.FloatTensor).cuda() y = Variable(y_batch).type(tor.LongTensor).cuda() pred = fcn(x) optim1.zero_grad() optim2.zero_grad() optim3.zero_grad() optim4.zero_grad() optim.zero_grad() loss = loss_func(pred, y) loss.backward() optim1.step() optim2.step() optim3.step() optim4.step() print(pred[:2]) print(tor.max(pred[:5], 1)[1]) ### Evaluation loss = float(loss.data) acc = evaluate(fcn, x_eval_train, y_eval_train) print("|Loss: {:<8} |Acc: {:<8}".format(loss, acc)) ### Save model if epoch % RECORD_MODEL_PERIOD == 0: tor.save( fcn.state_dict(), os.path.join(MODEL_ROOT, "fcn_model_{}_{}.pkl".format(model_index, epoch))) ### Record record_data = dict() if epoch == 0: record_data["model_name"] = "fcn_model_{}.pkl".format(model_index) record_data["data_size"] = AVAILABLA_SIZE record_data["batch_size"] = BATCHSIZE record_data["decay"] = str((LR_STEPSIZE, LR_GAMMA)) record_data["lr_init"] = float(optim1.param_groups[0]["lr"]) record_data["lr"] = float(optim1.param_groups[0]["lr"]) record_data["record_epoch"] = RECORD_MODEL_PERIOD record_data["loss"] = loss record_data["acc"] = acc else: record_data["model_name"] = "fcn_model_{}.pkl".format(model_index) record_data["lr"] = float(optim1.param_groups[0]["lr"]) record_data["loss"] = loss record_data["acc"] = acc record(RECORD_FP, record_data)
global current_synthesized_model, synthesizer encoder.load_model("Real_Time_Voice_Cloning/pretrained/encoder/saved_models/pretrained.pt", "cpu") # what is this used for vocoder.load_model("Real_Time_Voice_Cloning/pretrained/vocoder/saved_models/pretrained.pt", verbose=False) # todo: figure out how the multiple utterances work synthesizer = get_synthesizer("Real_Time_Voice_Cloning/pretrained/synthesizer/saved_models/logs-pretrained") if len(text) > 4 and text[-4:] == ".txt": # check if file words = "" with open(text) as file: for line in file: words += line text = words del words if isinstance(audio_samples, str): utterance = Utterance("name", "speaker_name", None, None, np.load(audio_samples), None, None) else: utterance = create_utterance(audio_samples) current_synthesized_model = generate_spectrogram(text, utterance) audio_file = decode_spectrogram(*current_synthesized_model) return audio_file, utterance.embed if __name__ == '__main__': sample_rate = syn_params.hparams.sample_rate while True: input("Hit enter to record:") wav = utils.record(sample_rate, 5) input("Hit enter to play") utils.play(wav, sample_rate) print(wav.shape)
def train(args): logging.info("start load parameters.") torch.manual_seed(args.seed) if args.dataset_name != 'mnist': num_chans = [args.nhid] * (args.levels - 1) + [args.emsize] else: num_chans = [args.nhid] * args.levels logger = SummaryWriter(args.dir_log) # load data logging.info("start load {} dataset.".format(args.dataset_name)) train_dataset = RawDataset(args.dir_data_root, args.dataset_name, 'train', args.seq_len, args.valid_len, args.is_corpus, args.permute) valid_dataset = RawDataset(args.dir_data_root, args.dataset_name, 'valid', args.seq_len, args.valid_len, args.is_corpus, args.permute) test_dataset = RawDataset(args.dir_data_root, args.dataset_name, 'test', args.seq_len, args.valid_len, args.is_corpus, args.permute) train_dataloader = load_dataloader(train_dataset, args.batch_size, num_workers=args.num_workers) valid_dataloader = load_dataloader(valid_dataset, args.batch_size, num_workers=args.num_workers) test_dataloader = load_dataloader(test_dataset, args.batch_size, num_workers=args.num_workers) n_dict = train_dataset.n_dict logging.info("end -------------") # define model logging.info("start load model.") model = TCANet(args.emsize, n_dict, num_chans, args.valid_len, args.num_subblocks, temp_attn=args.temp_attn, nheads=args.nheads, en_res=args.en_res, conv=args.conv, dropout=args.dropout, emb_dropout=args.emb_dropout, key_size=args.key_size, kernel_size=args.ksize, tied_weights=args.tied, dataset_name=args.dataset_name, visual=args.visual) num_parameters_train = sum(p.numel() for p in model.parameters() if p.requires_grad) logging.info("Number of parameters = {}".format(num_parameters_train)) if args.cuda: model.cuda(args.gpu_id) if args.is_parallel: model = nn.DataParallel(model) logging.info("The model is training with nn.DataParallel.") if args.continue_train: model = load_model(model, args) logging.info("Continue training, load saved model.") criterion = nn.CrossEntropyLoss() lr = args.lr optimizer = getattr(optim, args.optim)(model.parameters(), lr=lr) visual_info_all = [] best_vloss = 1e8 # start training logging.info("start training.") try: all_vloss = [] for epoch in range(args.epochs): epoch_start_time = time.time() model.train() loss_sum = 0 processed_data_size = 0 correct_total = 0 for i, (train_batch, label_batch) in enumerate(tqdm(train_dataloader, ncols=80)): optimizer.zero_grad() train_batch = train_batch.cuda(args.gpu_id) label_batch = label_batch.cuda(args.gpu_id) if args.temp_attn: output_batch, attn_weight_list = model(train_batch) if i == 1: visual_info = [ train_batch, label_batch, attn_weight_list ] else: output_batch = model(train_batch) # Discard the effective history part eff_history = args.seq_len - args.valid_len if eff_history < 0: raise ValueError( "Valid sequence length must be smaller than sequence length!" ) if args.dataset_name != 'mnist': label_batch = label_batch[:, eff_history:].contiguous().view( -1) output_batch = output_batch[:, eff_history:].contiguous( ).view(-1, n_dict) else: pred = output_batch.data.max(1, keepdim=True)[1] correct_total += pred.eq( label_batch.data.view_as(pred)).cpu().sum() loss_i = criterion(output_batch, label_batch) loss_i.backward() if args.clip > 0: torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip) optimizer.step() if args.dataset_name != 'mnist': loss_sum += (train_batch.size(1) - eff_history) * loss_i.item() processed_data_size += train_batch.size(1) - eff_history else: loss_sum += loss_i.item() processed_data_size += 1 if args.dataset_name == 'mnist': acc_train = 100 * float(correct_total) / len(train_dataset) loss_train = round(loss_sum / processed_data_size, 6) ppl_train = round(np.exp(loss_train), 4) epoch_end_time = time.time() # evaluate loss_val, ppl_val = evaluate(model, valid_dataloader, criterion, n_dict, args) loss_test, ppl_test = evaluate(model, test_dataloader, criterion, n_dict, args) # draw sequence correlation map if args.temp_attn and args.visual: visual_info_all.append(visual_info) if epoch == 0: draw_attn(visual_info, epoch, args, train_dataset.dictionary) else: draw_attn(visual_info, epoch, args) # tensorboard if args.dataset_name == 'mnist': logging.info('| Epoch {}/{} | Time: {:.2f}s | train loss {:.2f} | train acc {:.2f} | test loss {:.2f} | test acc {:.2f} |'\ .format(epoch+1, args.epochs, epoch_end_time-epoch_start_time, loss_train, acc_train, loss_test, ppl_test)) logger_note = args.log logger.add_scalars('{}/train_loss'.format(logger_note), {'loss_train': loss_train}, epoch) logger.add_scalars('{}/train_acc'.format(logger_note), {'acc_train': acc_train}, epoch) logger.add_scalars('{}/test_loss'.format(logger_note), {'loss_test': loss_test}, epoch) logger.add_scalars('{}/test_acc'.format(logger_note), {'acc_test': ppl_test}, epoch) else: logging.info('| Epoch {}/{} | Time: {:.2f}s | train loss {:.2f} | train ppl {:.2f} | test loss {:.2f} | test ppl {:.2f} |'\ .format(epoch+1, args.epochs, epoch_end_time-epoch_start_time, loss_train, ppl_train, loss_test, ppl_test)) logger_note = args.log logger.add_scalars('{}/train_loss'.format(logger_note), {'loss_train': loss_train}, epoch) logger.add_scalars('{}/train_ppl'.format(logger_note), {'ppl_train': ppl_train}, epoch) logger.add_scalars('{}/test_loss'.format(logger_note), {'loss_test': loss_test}, epoch) logger.add_scalars('{}/test_ppl'.format(logger_note), {'ppl_test': ppl_test}, epoch) # Save the model if the validation loss is the best we've seen so far. if loss_val < best_vloss: save_model(model, args) best_vloss = loss_val # Anneal the learning rate if the validation loss plateaus if epoch > 5 and loss_val >= max(all_vloss[-5:]): lr = lr / 2. for param_group in optimizer.param_groups: param_group['lr'] = lr all_vloss.append(loss_val) except KeyboardInterrupt: # after Ctrl + C, print final result logging.info('-' * 40) logging.info('Exiting from training early') model = load_model(model, args) loss_test, ppl_test = evaluate(model, test_dataloader, criterion, n_dict, args) logging.info('-' * 40) logging.info("log = {}".format(args.log)) logging.info("Number of parameters = {}".format(num_parameters_train)) if args.dataset_name == 'mnist': logging.info('| test loss {:.2f} | test acc {:.2f}'.format( loss_test, ppl_test)) else: logging.info('| test loss {:.2f} | test ppl {:.2f}'.format( loss_test, ppl_test)) logging.info('-' * 40) logger.close() end_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") # store result record(end_time, args.path_results, args.dataset_name, args.optim, args.key_size, args.vhdropout, args.levels, args.batch_size, args.epochs, args.lr, args.num_subblocks, args.en_res, args.temp_attn, loss_test, ppl_test, num_parameters_train, args.log) # print final result logger.close() model = load_model(model, args) loss_test, ppl_test = evaluate(model, test_dataloader, criterion, n_dict, args) logging.info('-' * 40) logging.info("log = {}".format(args.log)) logging.info("Number of parameters = {}".format(num_parameters_train)) if args.dataset_name == 'mnist': logging.info('| test loss {:.2f} | test acc {:.2f}'.format( loss_test, ppl_test)) else: logging.info('| test loss {:.2f} | test ppl {:.2f}'.format( loss_test, ppl_test)) logging.info('-' * 40) # store attention weights if args.temp_attn: save_visual_info(visual_info_all, args) end_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") # store result record(end_time, args.path_results, args.dataset_name, args.optim, args.key_size, args.vhdropout, args.levels, args.batch_size, \ args.epochs, args.lr, args.num_subblocks, args.en_res, args.temp_attn, loss_test, ppl_test, num_parameters_train, args.log)