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)
