def toggle_active(): if not config.system_active: startup() config.process = subprocess.Popen('./sensor.py') config.system_active = True else: reset() config.process.kill() config.system_active = False config.alerts_triggered = 0 return redirect(url_for('index'))
def reset(self, path): utils.reset(path) utils.set_stack(self.quantity) utils.set_timer(self.timer) self.infos = dict() start_time = utils.get_start_time() assert start_time != -1 self.infos["start_time"] = start_time for _, agent in self.agents.items(): agent.update_eps()
def updateParkspot(self, total_places_count, occupied_places_count): print("Update parkspot data") parkspotdata = swagger_client.UpdateParkspotStatus() parkspotdata.local_ip = getLocalIP() parkspotdata.total_places_count = total_places_count parkspotdata.occupied_places_count = occupied_places_count try: api_response = self.api_instance.update_parkspotnodes_status( self.info["token"], parkspotdata, self.info["parkspot_id"]) if api_response.error.status == 404: print("Could not update parkspotdata. Resetting") reset() return True except ApiException as e: return False
def main(): info = {"parkspot_id": "", "token": ""} # Load Parkspot ID and Token infoPath = Path(settings.infoFile) if infoPath.is_file(): info = (pickle.load(open(settings.infoFile, "rb"))) tokenAvailable = True if (info['token'] == ""): tokenAvailable = False networkAvailable = hasNetwork() if networkAvailable is False or tokenAvailable is False: setupParkspot(info) api = ParkspotApi(info) # Create a new parkspot if we did not create one yet if info["parkspot_id"] == "": if api.createParkspot() is False: print("Could not create Parkspot. Resetting") reset() pickle.dump(info, open(settings.infoFile, "w+b")) # Tell the backend our IP if api.updateLocalIp() is False: print("Could update IP. Resetting") shutdown() # Initialize the camera and the model print("Starting model") cam = Camera(usePiCamera=False, resolution=(1280, 720)) model = CNN(cam, 'cnn/model/complexCNN.h5', api) # Create the parkspot grpc service service = ParkspotService(cam, model, api) # Run model while True: model.detect() time.sleep(5) # When everything is done, release everything cv2.destroyAllWindows() service.stop()
def check(): while True: if config.debug: logging.debug('checking metrics...') for plugin in plugins: for target in plugin.targets: for metric in target.metrics: if metric.value is None: update_metric(metric) value = metric.value if target.min <= value <= target.max: reset(metric) else: if metric.retry < target.retry: metric.retry += 1 if metric.retry == 3: messages.append((target, deepcopy(metric))) # metric.retry = 0 # re-schedule time.sleep(10) # check interval
def onSettingsChanged(self): # Monitor emby settings currentPath = utils.settings('useDirectPaths') if utils.window('emby_pluginpath') != currentPath: # Plugin path value changed. Offer to reset self.logMsg("Changed to playback mode detected", 1) utils.window('emby_pluginpath', value=currentPath) resp = xbmcgui.Dialog().yesno( heading="Playback mode change detected", line1=( "Detected the playback mode has changed. The database " "needs to be recreated for the change to be applied. " "Proceed?")) if resp: utils.reset() currentLog = utils.settings('logLevel') if utils.window('emby_logLevel') != currentLog: # The log level changed, set new prop self.logMsg("New log level: %s" % currentLog, 1) utils.window('emby_logLevel', value=currentLog)
def main(): ################ load ################### #train_agent actor_train_path = os.path.abspath( os.curdir) + '/Generate_Traffic_Flow_MAS_RL/weight/AC_TD3_actor.pkl' critic_train_path = os.path.abspath( os.curdir) + '/Generate_Traffic_Flow_MAS_RL/weight/AC_TD3_critic.pkl' if os.path.exists(actor_train_path): actor_train = Actor(state_size, action_size).to(device) actor_train.load_state_dict(torch.load(actor_train_path)) print('Actor_Train Model loaded') else: actor_train = Actor(state_size, action_size).to(device) if os.path.exists(critic_train_path): critic_train = Critic(state_size, action_size).to(device) critic_train.load_state_dict(torch.load(critic_train_path)) print('Critic_Train Model loaded') else: critic_train = Critic(state_size, action_size).to(device) critic_next_train = Critic(state_size, action_size).to(device) critic_next_train.load_state_dict(critic_train.state_dict()) #agents actor_path = os.path.abspath( os.curdir) + '/Generate_Traffic_Flow_MAS_RL/weight/AC_TD_MAS_actor.pkl' if os.path.exists(actor_path): actor = Actor(state_size, action_size).to(device) actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') print("Waiting for GAMA...") ################### initialization ######################## reset() episode = 0 training_stage = 65 lr = 0.0001 sample_lr = [ 0.0001, 0.00009, 0.00008, 0.00007, 0.00006, 0.00005, 0.00004, 0.00003, 0.00002, 0.00001, 0.000009, 0.000008, 0.000007, 0.000006, 0.000005, 0.000004, 0.000003, 0.000002, 0.000001 ] if episode > training_stage: #50 100 try: lr = sample_lr[int(episode // training_stage)] * 0.01 except (IndexError): lr = 0.000001 * 0.9 #* (0.9 ** ((episode-1000) // 60)) optimizerA = optim.Adam(actor_train.parameters(), lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic_train.parameters(), lr, betas=(0.95, 0.999)) values = [] rewards = [] masks = [] total_loss = [] total_rewards = [] loss = [] average_speed = [] value = 0 gama = 0.9 over = 0 log_prob = 0 memory = Memory() A_T, state, reward, done, time_pass, over, average_speed_NPC = GAMA_connect( ) print("Connected") ################## start ######################### while over != 1: #training_agent if A_T == 0: #普通の場合 average_speed.append(state[0]) if (done == 0 and time_pass != 0): #前回の報酬 reward = torch.tensor([reward], dtype=torch.float, device=device) rewards.append(reward) state = torch.DoubleTensor(state).reshape( 1, state_size).to(device) state_img = generate_img_train() tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to(device) / 255 if len(memory.states_next) == 0: #for _ in range(3): memory.states_next = memory.states memory.states_next[2] = state memory.states_img_next = memory.states_img memory.states_img_next[2] = tensor_cv else: del memory.states_next[:1] del memory.states_img_next[:1] memory.states_next.append(state) memory.states_img_next.append(tensor_cv) state_next = torch.stack( memory.states_next).to(device).detach() tensor_cv_next = torch.stack( memory.states_img_next).to(device).detach() value_next, _, _, _ = critic_next_train( state_next, tensor_cv_next, h_state_cv_c, h_state_n_c, h_state_3_c) #_next with torch.autograd.set_detect_anomaly(True): # TD:r(s) + gama*v(s+1) - v(s) advantage = reward.detach( ) + gama * value_next.detach() - value actor_loss = -(log_prob * advantage.detach()) critic_loss = (reward.detach() + gama * value_next.detach() - value).pow(2) optimizerA.zero_grad() optimizerC.zero_grad() critic_loss.backward() actor_loss.backward() loss.append(critic_loss) optimizerA.step() optimizerC.step() critic_next_train.load_state_dict( critic_train.state_dict()) del memory.states[:1] del memory.states_img[:1] memory.states.append(state) memory.states_img.append(tensor_cv) state = torch.stack(memory.states).to(device).detach() tensor_cv = torch.stack(memory.states_img).to(device).detach() value, h_state_cv_c, h_state_n_c, h_state_3_c = critic_train( state, tensor_cv, h_state_cv_c, h_state_n_c, h_state_3_c) action, log_prob = actor_train(state, tensor_cv) log_prob = log_prob.unsqueeze(0) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) #行 masks.append( torch.tensor([1 - done], dtype=torch.float, device=device)) values.append(value) # 終わり elif done == 1: average_speed.append(state[0]) send_to_GAMA([[1, 0]]) #先传后计算 print(state) rewards.append(reward) #contains the last reward = torch.tensor([reward], dtype=torch.float, device=device) rewards.append(reward) #contains the last total_reward = sum(rewards).cpu().detach().numpy() total_rewards.append(total_reward) with torch.autograd.set_detect_anomaly(True): advantage = reward.detach( ) - value #+ last_value 最后一回的V(s+1) = 0 actor_loss = -(log_prob * advantage.detach()) critic_loss = (reward.detach() - value).pow( 2) #+ last_value optimizerA.zero_grad() optimizerC.zero_grad() critic_loss.backward() actor_loss.backward() loss.append(critic_loss) optimizerA.step() optimizerC.step() critic_next_train.load_state_dict( critic_train.state_dict()) print( "----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 values = [] rewards = [] loss_sum = sum(loss).cpu().detach().numpy() total_loss.append(loss_sum) cross_loss_curve(loss_sum.squeeze(0), total_reward, save_curve_pic, save_critic_loss, save_reward, np.mean(average_speed), save_speed, average_speed_NPC, save_NPC_speed) #total_loss,total_rewards#np.mean(average_speed)/10 loss = [] average_speed = [] memory.clear_memory() torch.save(actor_train.state_dict(), actor_train_path) torch.save(critic_train.state_dict(), critic_train_path) if episode > training_stage: #50 100 try: lr = sample_lr[int(episode // training_stage)] * 0.01 except (IndexError): lr = 0.000001 * 0.9 #* (0.9 ** ((episode-1000) // 60)) optimizerA = optim.Adam(actor_train.parameters(), lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic_train.parameters(), lr, betas=(0.95, 0.999)) #最初の時 if time_pass == 0: print('Iteration:', episode, "lr:", lr) state = np.reshape(state, (1, len(state))) state_img = generate_img_train() tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to(device) / 255 state = torch.DoubleTensor(state).reshape( 1, state_size).to(device) for _ in range(3): memory.states.append(state) memory.states_img.append(tensor_cv) state = torch.stack(memory.states).to(device).detach() ### tensor_cv = torch.stack(memory.states_img).to(device).detach() value, h_state_cv_c, h_state_n_c, h_state_3_c = critic_train( state, tensor_cv) #dist, # now is a tensoraction = dist.sample() action, log_prob = actor_train(state, tensor_cv) print("acceleration: ", action.cpu().numpy()) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) #agents if A_T == 1: state = [ torch.DoubleTensor(elem).reshape(1, state_size).to(device) for elem in state ] state = torch.stack(state).to(device).detach() tensor_cv_MAS = generate_img() tensor_cv_MAS = [ torch.from_numpy(np.transpose(elem, (2, 0, 1))).double().to(device) / 255 for elem in tensor_cv_MAS ] tensor_cv_MAS = torch.stack(tensor_cv_MAS).to(device).detach() action, _ = actor(state, tensor_cv_MAS) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) A_T, state, reward, done, time_pass, over, average_speed_NPC = GAMA_connect( ) return None
def main(): ############## Hyperparameters ############## update_timestep = 1 #TD use == 1 # update policy every n timesteps set for TD K_epochs = 4 # update policy for K epochs lr太大会出现NAN? eps_clip = 0.2 gamma = 0.9 episode = 512 sample_lr = [ 0.0001, 0.00009, 0.00008, 0.00007, 0.00006, 0.00005, 0.00004, 0.00003, 0.00002, 0.00001, 0.000009, 0.000008, 0.000007, 0.000006, 0.000005, 0.000004, 0.000003, 0.000002, 0.000001 ] lr = 0.0001 #random_seed = None state_dim = 5 action_dim = 1 #(self, state_dim, action_dim, lr, betas, gamma, K_epochs, eps_clip) actor_path = os.getcwd( ) + '/PPO_Mixedinput_Navigation_Model/weight/ppo_TD2lstm_actor.pkl' critic_path = os.getcwd( ) + '/PPO_Mixedinput_Navigation_Model/weight/ppo_TD2lstm_critic.pkl' ################ load ################### if episode > 50: #50 100 try: lr = sample_lr[int(episode // 50)] except (IndexError): lr = 0.000001 ppo = PPO(state_dim, action_dim, lr, gamma, K_epochs, eps_clip) if os.path.exists(actor_path): ppo.actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') if os.path.exists(critic_path): ppo.critic.load_state_dict(torch.load(critic_path)) print('Critic Model loaded') print("Waiting for GAMA...") ################### initialization ######################## save_curve_pic = os.getcwd( ) + '/PPO_Mixedinput_Navigation_Model/result/PPO_2LSTM_loss_curve.png' save_critic_loss = os.getcwd( ) + '/PPO_Mixedinput_Navigation_Model/training_data/PPO_TD2_critic_loss.csv' save_reward = os.getcwd( ) + '/PPO_Mixedinput_Navigation_Model/training_data/PPO_TD2_reward.csv' reset() memory = Memory() advantages = 0 #global value loss = [] total_loss = [] rewards = [] total_rewards = [] test = "GAMA" state, reward, done, time_pass, over = GAMA_connect(test) #connect #[real_speed/10, target_speed/10, elapsed_time_ratio, distance_left/100,distance_front_car/10,distance_behind_car/10,reward,done,over] print("done:", done, "timepass:"******"state ",state) rewards.append(reward) memory.rewards.append(reward) memory.is_terminals.append(done) state = torch.DoubleTensor(state).reshape(1, state_dim).to(device) state_img = generate_img() tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to(device) if len(memory.states_next) == 0: for _ in range(3): memory.states_next = memory.states memory.states_next[2] = state memory.states_img_next = memory.states_img memory.states_img_next[2] = tensor_cv else: del memory.states_next[:1] del memory.states_img_next[:1] memory.states_next.append(state) memory.states_img_next.append(tensor_cv) loss_ = ppo.update(memory, lr, advantages, done) loss.append(loss_) del memory.logprobs[:] del memory.rewards[:] del memory.is_terminals[:] #memory.clear_memory() action = ppo.select_action(state, tensor_cv, memory) send_to_GAMA([[1, float(action * 10)]]) #print("acceleration ",float(action)) # 終わり elif done == 1: #先传后计算 print("state_last", state) send_to_GAMA([[1, 0]]) rewards.append(reward) del memory.states_next[:1] del memory.states_img_next[:1] state = torch.DoubleTensor(state).reshape(1, state_dim).to( device) #转化成1行 memory.states_next.append(state) state_img = generate_img() tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to(device) memory.states_img_next.append(tensor_cv) memory.rewards.append(reward) memory.is_terminals.append(done) loss_ = ppo.update(memory, lr, advantages, done) loss.append(loss_) memory.clear_memory() print( "----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 loss_sum = sum(loss).cpu().detach().numpy() total_loss.append(loss_sum) total_reward = sum(rewards) total_rewards.append(total_reward) cross_loss_curve(loss_sum.squeeze(0), total_reward, save_curve_pic, save_critic_loss, save_reward) rewards = [] loss = [] if episode > 50: #50 100 try: lr = sample_lr[int(episode // 50)] except (IndexError): lr = 0.000001 torch.save(ppo.actor.state_dict(), actor_path) torch.save(ppo.critic.state_dict(), critic_path) #最初の時 else: print('Iteration:', episode, "lr:", lr) state = torch.DoubleTensor(state).reshape(1, state_dim).to(device) state_img = generate_img( ) # numpy image: H x W x C (500, 500, 3) -> (3,500,500) tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to( device ) # np.transpose( xxx, (2, 0, 1)) torch image: C x H x W action = ppo.select_action(state, tensor_cv, memory) print("acceleration: ", action) send_to_GAMA([[1, float(action * 10)]]) state, reward, done, time_pass, over = GAMA_connect(test) return None
def main(): ################ load ################### actor_path = os.path.abspath( os.curdir ) + '\\GAMA_python\\PPO_Mixedinput_Navigation_Model\\weight\\AC_TD_actor.pkl' critic_path = os.path.abspath( os.curdir ) + '\\GAMA_python\\PPO_Mixedinput_Navigation_Model\\weight\\AC_TD_critic.pkl' if os.path.exists(actor_path): actor = Actor(state_size, action_size).to(device) actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') else: actor = Actor(state_size, action_size).to(device) if os.path.exists(critic_path): critic = Critic(state_size, action_size).to(device) critic.load_state_dict(torch.load(critic_path)) print('Critic Model loaded') else: critic = Critic(state_size, action_size).to(device) critic_next = Critic(state_size, action_size).to(device) critic_next.load_state_dict(critic.state_dict()) print("Waiting for GAMA...") ################### initialization ######################## reset() episode = 237 lr = 0.0001 if episode > 50: lr = 0.00008 new_lr = lr * (0.9**((episode - 40) // 10)) #if episode > 110: # lr = 0.000008 # new_lr = lr * (0.9 ** ((episode-90) // 10)) #40 optimizerA = optim.Adam(actor.parameters(), lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), lr, betas=(0.95, 0.999)) test = "GAMA" state, reward, done, time_pass, over = GAMA_connect(test) #connect print("done:", done, "timepass:"******"restart acceleration: 0") send_to_GAMA([[1, 0]]) #先传后计算 print(state) rewards.append(reward) #contains the last reward = torch.tensor([reward], dtype=torch.float, device=device) rewards.append(reward) #contains the last total_reward = sum(rewards).cpu().detach().numpy() total_rewards.append(total_reward) #state = torch.FloatTensor(state).reshape(1,4).to(device) #last_value= critic(state) with torch.autograd.set_detect_anomaly(True): advantage = reward.detach( ) - value #+ last_value 最后一回的V(s+1) = 0 actor_loss = -(log_prob * advantage.detach()) critic_loss = (reward.detach() - value).pow(2) #+ last_value lstm_loss = critic_loss optimizerA.zero_grad() optimizerC.zero_grad() critic_loss.backward() actor_loss.backward() loss.append(critic_loss) optimizerA.step() optimizerC.step() critic_next.load_state_dict(critic.state_dict()) print( "----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 log_probs = [] values = [] rewards = [] masks = [] loss_sum = sum(loss).cpu().detach().numpy() total_loss.append(loss_sum) cross_loss_curve(loss_sum.squeeze(0), total_reward, save_curve_pic, save_critic_loss, save_reward) #total_loss,total_rewards loss = [] if episode > 50: lr = 0.00008 new_lr = lr * (0.9**((episode - 40) // 10)) #if episode > 110: # lr = 0.000008 # new_lr = lr * (0.9 ** ((episode-90) // 10)) #40 optimizerA = optim.Adam(actor.parameters(), new_lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), new_lr, betas=(0.95, 0.999)) torch.save(actor.state_dict(), actor_path) torch.save(critic.state_dict(), critic_path) #最初の時 else: print('Iteration:', episode) state = np.reshape(state, (1, len(state))) #xxx state_img = generate_img() tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to(device) state = torch.DoubleTensor(state).reshape(1, 6).to(device) value = critic( state, tensor_cv) #dist, # now is a tensoraction = dist.sample() action, log_prob, entropy = actor(state, tensor_cv) print("acceleration: ", action.cpu().numpy()) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) log_prob = log_prob.unsqueeze(0) entropy += entropy state, reward, done, time_pass, over = GAMA_connect(test) return None
def main(): ############## Hyperparameters ############## update_timestep = 1 #TD use == 1 # update policy every n timesteps set for TD K_epochs = 2 # update policy for K epochs lr太大会出现NAN? eps_clip = 0.2 gamma = 0.9 episode = 376 lr_first = 0.0001 lr = lr_first #random_seed = None state_dim = 6 action_dim = 1 #(self, state_dim, action_dim, lr, betas, gamma, K_epochs, eps_clip) actor_path = os.getcwd( ) + '\\GAMA_python\\PPO_Navigation_Model\\weight\\ppo_TD_actor.pkl' critic_path = os.getcwd( ) + '\\GAMA_python\\PPO_Navigation_Model\\weight\\ppo_TD_critic.pkl' ################ load ################### if episode > 70: #50 100 lr_first = 0.00001 lr = lr_first * (0.65**((episode - 60) // 10)) ppo = PPO(state_dim, action_dim, lr, gamma, K_epochs, eps_clip) if os.path.exists(actor_path): ppo.actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') if os.path.exists(critic_path): ppo.critic.load_state_dict(torch.load(critic_path)) print('Critic Model loaded') print("Waiting for GAMA...") ################### initialization ######################## save_curve_pic = os.getcwd( ) + '\\GAMA_python\\PPO_Navigation_Model\\result\\PPO_TD_loss_curve.png' save_critic_loss = os.getcwd( ) + '\\GAMA_python\\PPO_Navigation_Model\\training_data\\PPO_TD_critic_loss.csv' save_reward = os.getcwd( ) + '\\GAMA_python\\PPO_Navigation_Model\\training_data\\PPO_TD_reward.csv' reset() memory = Memory() advantages = 0 #global value loss = [] total_loss = [] rewards = [] total_rewards = [] test = "GAMA" state, reward, done, time_pass, over = GAMA_connect(test) #connect #[real_speed/10, target_speed/10, elapsed_time_ratio, distance_left/100,distance_front_car/10,distance_behind_car/10,reward,done,over] print("done:", done, "timepass:"******"state_last", state) send_to_GAMA([[1, 0]]) rewards.append(reward) state = torch.DoubleTensor(state).reshape(1, 6).to(device) #转化成1行 memory.states_next.append(state) memory.rewards.append(reward) memory.is_terminals.append(done) loss_ = ppo.update(memory, lr, advantages, done) loss.append(loss_) memory.clear_memory() print( "----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 loss_sum = sum(loss).cpu().detach().numpy() total_loss.append(loss_sum) total_reward = sum(rewards) total_rewards.append(total_reward) cross_loss_curve(loss_sum.squeeze(0), total_reward, save_curve_pic, save_critic_loss, save_reward) rewards = [] loss = [] if episode > 70: #50 100 lr_first = 0.00001 lr = lr_first * (0.65**((episode - 60) // 10)) #40 90 torch.save(ppo.actor.state_dict(), actor_path) torch.save(ppo.critic.state_dict(), critic_path) #最初の時 else: print('Iteration:', episode) state = torch.DoubleTensor(state).reshape(1, 6).to(device) action = ppo.select_action(state, memory) print("acceleration: ", action) #.cpu().numpy() send_to_GAMA([[1, float(action * 10)]]) state, reward, done, time_pass, over = GAMA_connect(test) return None
def main(): ################ load ################### actor_path = os.path.abspath( os.curdir) + '/PPO_Mixedinput_Navigation_Model/weight/AC_TD3_actor.pkl' critic_path = os.path.abspath( os.curdir ) + '/PPO_Mixedinput_Navigation_Model/weight/AC_TD3_critic.pkl' if os.path.exists(actor_path): actor = Actor(state_size, action_size).to(device) actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') else: actor = Actor(state_size, action_size).to(device) if os.path.exists(critic_path): critic = Critic(state_size, action_size).to(device) critic.load_state_dict(torch.load(critic_path)) print('Critic Model loaded') else: critic = Critic(state_size, action_size).to(device) critic_next = Critic(state_size, action_size).to(device) critic_next.load_state_dict(critic.state_dict()) print("Waiting for GAMA...") ################### initialization ######################## reset() episode = 4000 training_stage = 70 #100#80 Decay = training_stage * 18 lr = 0.0001 sample_lr = [ 0.0001, 0.00009, 0.00008, 0.00007, 0.00006, 0.00005, 0.00004, 0.00003, 0.00002, 0.00001, 0.000009, 0.000008, 0.000007, 0.000006, 0.000005, 0.000004, 0.000003, 0.000002, 0.000001 ] #900 960 1020 1080 1140 if episode >= training_stage: #50 100 try: lr = sample_lr[int(episode // training_stage)] except (IndexError): lr = 0.000001 * (0.9**((episode - Decay // training_stage)) ) #100-1800#80-1440#65-1170#570 -- 30 optimizerA = optim.Adam(actor.parameters(), lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), lr, betas=(0.95, 0.999)) test = "GAMA" state, reward, done, time_pass, over, _ = GAMA_connect(test) #connect print("done:", done, "timepass:"******"----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 #最初の時 else: print('Iteration:', episode, "lr:", lr) state = np.reshape(state, (1, len(state))) #xxx state_img = generate_img() tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to(device) / 255 state = torch.DoubleTensor(state).reshape(1, state_size).to(device) for _ in range(Memory_size): memory.states.append(state) memory.states_img.append(tensor_cv) state = torch.stack(memory.states).to(device).detach() ### tensor_cv = torch.stack(memory.states_img).to(device).detach() value, h_state_cv_c, h_state_n_c, h_state_3_c = critic( state, tensor_cv) #dist, # now is a tensoraction = dist.sample() action, log_prob, entropy = actor( state, tensor_cv) #, h_state_cv_a,h_state_n_a,h_state_3_a print("acceleration: ", action.cpu().numpy()) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) log_prob = log_prob.unsqueeze(0) #entropy += entropy state, reward, done, time_pass, over, average_speed_NPC = GAMA_connect( test) return None
def __init__(self): log.debug('Full sys.argv received: %s' % argv) # Parse parameters params = dict(parse_qsl(argv[2][1:])) mode = params.get('mode', '') itemid = params.get('id', '') if mode == 'play': self.play() elif mode == 'plex_node': self.play() elif mode == 'ondeck': entrypoint.getOnDeck(itemid, params.get('type'), params.get('tagname'), int(params.get('limit'))) elif mode == 'recentepisodes': entrypoint.getRecentEpisodes(itemid, params.get('type'), params.get('tagname'), int(params.get('limit'))) elif mode == 'nextup': entrypoint.getNextUpEpisodes(params['tagname'], int(params['limit'])) elif mode == 'inprogressepisodes': entrypoint.getInProgressEpisodes(params['tagname'], int(params['limit'])) elif mode == 'browseplex': entrypoint.browse_plex(key=params.get('key'), plex_section_id=params.get('id')) elif mode == 'getsubfolders': entrypoint.GetSubFolders(itemid) elif mode == 'watchlater': entrypoint.watchlater() elif mode == 'channels': entrypoint.channels() elif mode == 'settings': executebuiltin('Addon.OpenSettings(%s)' % v.ADDON_ID) elif mode == 'enterPMS': entrypoint.enterPMS() elif mode == 'reset': reset() elif mode == 'togglePlexTV': entrypoint.togglePlexTV() elif mode == 'resetauth': entrypoint.resetAuth() elif mode == 'passwords': passwordsXML() elif mode == 'switchuser': entrypoint.switchPlexUser() elif mode in ('manualsync', 'repair'): if window('plex_online') != 'true': # Server is not online, do not run the sync dialog('ok', heading=lang(29999), message=lang(39205)) log.error('Not connected to a PMS.') else: if mode == 'repair': window('plex_runLibScan', value='repair') log.info('Requesting repair lib sync') elif mode == 'manualsync': log.info('Requesting full library scan') window('plex_runLibScan', value='full') elif mode == 'texturecache': window('plex_runLibScan', value='del_textures') elif mode == 'chooseServer': entrypoint.chooseServer() elif mode == 'refreshplaylist': log.info('Requesting playlist/nodes refresh') window('plex_runLibScan', value='views') elif mode == 'deviceid': self.deviceid() elif mode == 'fanart': log.info('User requested fanarttv refresh') window('plex_runLibScan', value='fanart') elif '/extrafanart' in argv[0]: plexpath = argv[2][1:] plexid = itemid entrypoint.getExtraFanArt(plexid, plexpath) entrypoint.getVideoFiles(plexid, plexpath) # Called by e.g. 3rd party plugin video extras elif ('/Extras' in argv[0] or '/VideoFiles' in argv[0] or '/Extras' in argv[2]): plexId = itemid or None entrypoint.getVideoFiles(plexId, params) else: entrypoint.doMainListing(content_type=params.get('content_type'))
def main(): ############## Hyperparameters ############## K_epochs = 3 # update policy for K epochs lr太大会出现NAN? eps_clip = 0.2 gamma = 0.9 # 要较弱;较强关联? 对每一正确步也有打击 episode = 3 lr_first = 0.00001 lr = lr_first #random_seed = None state_dim = 6 action_dim = 1 #(self, state_dim, action_dim, lr, betas, gamma, K_epochs, eps_clip) actor_path = os.getcwd( ) + '\\GAMA_python\\PPO_Mixedinput_Navigation_Model\\weight\\ppo_MC_actor.pkl' critic_path = os.getcwd( ) + '\\GAMA_python\\PPO_Mixedinput_Navigation_Model\\weight\\ppo_MC_critic.pkl' ################ load ################### if episode > 30: #50 100 lr_first = 0.00001 lr = lr_first * (0.7**((episode - 20) // 10)) ppo = PPO(state_dim, action_dim, lr, gamma, K_epochs, eps_clip) if os.path.exists(actor_path): ppo.actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') if os.path.exists(critic_path): ppo.critic.load_state_dict(torch.load(critic_path)) print('Critic Model loaded') print("Waiting for GAMA...") ################### initialization ######################## save_curve_pic = os.getcwd( ) + '\\GAMA_python\\PPO_Mixedinput_Navigation_Model\\result\\PPO_MC_loss_curve.png' save_critic_loss = os.getcwd( ) + '\\GAMA_python\\PPO_Mixedinput_Navigation_Model\\training_data\\PPO_MC_critic_loss.csv' save_reward = os.getcwd( ) + '\\GAMA_python\\PPO_Mixedinput_Navigation_Model\\training_data\\PPO_MC_reward.csv' reset() memory = Memory() advantages = 0 #global value loss = [] total_loss = [] rewards = [] total_rewards = [] test = "GAMA" state, reward, done, time_pass, over = GAMA_connect(test) #connect #[real_speed/10, target_speed/10, elapsed_time_ratio, distance_left/100,distance_front_car/10,distance_behind_car/10,reward,done,over] print("done:", done, "timepass:"******"----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 loss_sum = sum(loss).cpu().detach().numpy() total_loss.append(loss_sum) total_reward = sum(rewards) total_rewards.append(total_reward) cross_loss_curve(loss_sum.squeeze(0), total_reward, save_curve_pic, save_critic_loss, save_reward) rewards = [] loss = [] if episode > 30: #50 100 lr = lr_first * (0.94**((episode - 20) // 10)) #if episode > 80: # lr_first = 0.0001 # lr = lr_first * (0.94 ** ((episode-70) // 10)) torch.save(ppo.actor.state_dict(), actor_path) torch.save(ppo.critic.state_dict(), critic_path) #最初の時 else: print('Iteration:', episode) state = torch.DoubleTensor(state).reshape(1, 6).to(device) state_img = generate_img( ) # numpy image: H x W x C (500, 500, 3) -> (3,500,500) tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to( device ) # np.transpose( xxx, (2, 0, 1)) torch image: C x H x W action = ppo.select_action(state, tensor_cv, memory) print("acceleration: ", action) #.cpu().numpy() send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) state, reward, done, time_pass, over = GAMA_connect(test) return None
DATA = list print list2 for i, row in enumerate(DATA): for j, col in enumerate(row): booksheet.write(j, i, col) # workbook.save('./data/dos_tichu_2500_1250_625_xlst.xls') return [experiment] + np.mean(results, axis=0).tolist() if __name__ == "__main__": reset() arguments = docopt(__doc__) pd.set_option("display.expand_frame_repr", False) pheno_path = "./data/phenotypes/Phenotypic_V1_0b_preprocessed949.csv" pheno = load_phenotypes(pheno_path) hdf5 = hdf5_handler("./data/abide_cc200_tichu.hdf5", "a") valid_derivatives = ["cc200", "aal", "ez", "ho", "tt", "dosenbach160"] derivatives = [ derivative for derivative in arguments["<derivative>"] if derivative in valid_derivatives ]
def main(mac): cont = False next_ring = False utils.debug('\n\n******TDB TEST******\n') # Starts TDB server utils.debug('Starting TDB server') tdb.start_tdb_server(os.environ['BT_PATH'], os.environ['TDB_PATH']) time.sleep(0.05) try: # Run connect first as a workaround to make tdb work tdb.connect(mac) time.sleep(0.05) tdb_res = 0 fail_str = '' pass_str = '' out_scan = tdb.start_scan() time.sleep(2) if 'ERROR' in out_scan: next_scan = False utils.debug('Error while enabling scan') fail_str += '\nenable-scan error' else: if ('set scan enabled' in out_scan): next_scan = True utils.debug('successfully enabled scan') tdb_res += 1 pass_str += '\nenable-scan pass' else: next_scan = False utils.debug('failed to enable scan') fail_str += '\nenable-scan failed' if next_scan is True: out_conn = tdb.connect(mac) time.sleep(0.05) if 'ERROR' in out_conn: utils.debug('Error happens when connecting to tdb') next_conn = False else: if ('error' in out_conn) or ('connection to tdb server \ failed' in out_conn): utils.debug('connection to tdb server failed') next_conn = False elif ('connection open!' in out_conn): utils.debug('successfully connected to tdb server') next_conn = True tdb_res += 1 pass_str += '\ntdb connect pass' if next_conn is False: for i in range(retries): try: utils.debug('Loop: ' + str(i + 1)) utils.debug('Resetting DUT ...') utils.reset(os.environ['nrfjprog_PATH']) time.sleep(5) tdb.start_tdb_server(os.environ['BT_PATH'], os.environ['TDB_PATH']) tdb.connect(mac) time.sleep(0.05) tdb.start_scan() time.sleep(2) out_conn = tdb.connect(mac) time.sleep(0.05) if ('connection open!' in out_conn): utils.debug('successfully connected to tdb server \ after ' + str(i + 1) + 'retries') next_conn = True tdb_res += 1 pass_str += '\ntdb connect pass' break except (subprocess.CalledProcessError) as detail: traceback.format_exc() print detail utils.debug(str(detail)) if i < 2: continue else: raise if next_conn is False: utils.debug('Failed to connect to tdb server after ' + str(retries) + ' retries') fail_str += '\ntdb connect failed' else: out_stop_scan = tdb.stop_scan() time.sleep(0.05) if 'ERROR' in out_stop_scan: utils.debug('Error while disabling scan') fail_str += '\ntdb disable-scan failed' else: tdb_res += 1 pass_str += '\ntdb disable-scan pass' out_onb_start = tdb.onboard_start(mac) time.sleep(0.05) if 'ERROR' in out_onb_start: utils.debug('onboard-start error') cont = False fail_str += '\ntdb onboard-start error' else: if 'received response' in out_onb_start: cont = True utils.debug('onboard start OK') tdb_res += 1 pass_str += '\ntdb onboard-start pass' else: cont = False utils.debug('Failed to start onboarding') fail_str += '\nonboard-start failed' if cont is True: out_onb_conf = tdb.onboard_confirm(mac) time.sleep(0.05) if 'ERROR' in out_onb_conf: cont = False utils.debug('onboard confirm error') fail_str += '\ntdb onboard-confirm error' else: if ('Tag device id' in out_onb_conf): cont = True utils.debug('onboard confirm OK') tdb_res += 1 pass_str += '\ntdb onboard-confirm pass' else: cont = False utils.debug('Failed to onboard confirm') fail_str += '\ntdb onboard-confirm failed' if cont is True: out_onb_cancel = tdb.onboard_cancel(mac) time.sleep(0.05) if 'ERROR' in out_onb_cancel: cont = False utils.debug('Off onboarding error') fail_str += '\ntdb onboard-cancel error' else: if ('received response' in out_onb_cancel): cont = True utils.debug('off boarding OK') tdb_res += 1 pass_str += '\ntdb onboard-cancel pass' else: cont = False utils.debug('off boarding failed') fail_str += '\ntdb onboard-cancel failed' if next_conn is True: out_ble_param = tdb.ble_param(mac, ble_param) time.sleep(0.05) if 'ERROR' in out_ble_param: utils.debug('Error when setting ble param') fail_str += '\ntdb ble-param error' else: if ('error code: 0' in out_ble_param): utils.debug('successfully setting ble param') tdb_res += 1 pass_str += '\ntdb ble-param pass' else: utils.debug('failed to set ble_param') fail_str += '\ntdb ble-param failed' if next_conn is True: out_ping = tdb.ping(mac, ping_msg) time.sleep(0.05) if 'ERROR' in out_ping: utils.debug('Error when pinging') fail_str += '\ntdb ping error' else: if ('received pong msg="Ping!"' in out_ping): utils.debug('ping OK') tdb_res += 1 pass_str += '\ntdb ping pass' else: utils.debug('ping failed') fail_str += '\ntdb ping failed' if next_conn is True: out_ring = tdb.ring_start(mac) time.sleep(0.05) if 'ERROR' in out_ring: utils.debug('Error when ringing') next_ring = False fail_str += '\ntdb ring error' else: if ('Ring indication: error code: 0' in out_ring): utils.debug('Ring OK') next_ring = True tdb_res += 1 pass_str += '\ntdb ring pass' else: utils.debug('Ring failed') next_ring = False fail_str += '\ntdb ring failed' if next_ring is True: out_ring_stop = tdb.ring_stop(mac) time.sleep(0.05) if 'ERROR' in out_ring_stop: utils.debug('ring-stop error') fail_str += '\ntdb ring-stop error' else: if ('Ring indication: error code: 0' in out_ring_stop): utils.debug('ring-stop OK') tdb_res += 1 pass_str += '\ntdb ring-stop pass' else: utils.debug('failed to stop ringing') fail_str += '\ntdb ring-stop failed' except subprocess.CalledProcessError as err: traceback.format_exc() utils.debug(str(err)) print err except KeyboardInterrupt: print '\nAborted by user\n' tdb.kill_tdb_server() time.sleep(0.05) finally: tdb.kill_tdb_server() time.sleep(0.05) if tdb_res == 10: utils.debug('All tdb commands PASS\n\n') utils.test_report('\n\nTDB test result:') utils.test_report('\nAll tdb commands PASS') else: utils.test_report('\n\nTDB test results: ') utils.test_report(pass_str + '\n') utils.test_report(fail_str + '\n\n')
from packet import Packet from random import randint from matplotlib import pyplot as plt from utils import reset, count_wins, report from globals import networks, SIZE, NTRIALS, PTIMES, STRATEGIES NTIME_STEPS = 200 NSERVERS = SIZE**2 win_freqs = {strategy : [] for strategy in STRATEGIES} if __name__ == '__main__': # Run SLB model simulation for ptime in PTIMES: for i in xrange(NTRIALS): reset(networks) for j in xrange(NTIME_STEPS): loc = randint(0, NSERVERS - 1) pkt = Packet('id-%d' % (j), ptime) for sim_obj in networks: network = sim_obj['obj'] network.step() network.add(pkt, loc) sim_obj['dat'][ptime][i] += network.latency() # Count and report win frequencies for ptime in PTIMES: win_counts = {strategy : 0 for strategy in STRATEGIES} count_wins(networks, ptime, win_counts, NTRIALS) report(win_counts, ptime, NTRIALS) for strategy, count in win_counts.iteritems():
def run_internal(self): startupComplete = False monitor = self.monitor self.logMsg("---===### Starting LibrarySync ###===---", 0) while not monitor.abortRequested(): # In the event the server goes offline while self.suspend_thread: # Set in service.py if monitor.waitForAbort(5): # Abort was requested while waiting. We should exit break if (utils.window('emby_dbCheck') != "true" and utils.settings('SyncInstallRunDone') == "true"): # Verify the validity of the database currentVersion = utils.settings('dbCreatedWithVersion') minVersion = utils.window('emby_minDBVersion') uptoDate = self.compareDBVersion(currentVersion, minVersion) if not uptoDate: self.logMsg( "Db version out of date: %s minimum version required: %s" % (currentVersion, minVersion), 0) resp = xbmcgui.Dialog().yesno( heading="Db Version", line1=( "Detected the database needs to be " "recreated for this version of Emby for Kodi. " "Proceed?")) if not resp: self.logMsg("Db version out of date! USER IGNORED!", 0) xbmcgui.Dialog().ok( heading="Emby for Kodi", line1=( "Emby for Kodi may not work correctly " "until the database is reset.")) else: utils.reset() utils.window('emby_dbCheck', value="true") if not startupComplete: # Verify the video database can be found videoDb = utils.getKodiVideoDBPath() if not xbmcvfs.exists(videoDb): # Database does not exists self.logMsg( "The current Kodi version is incompatible " "with the Emby for Kodi add-on. Please visit " "https://github.com/MediaBrowser/Emby.Kodi/wiki " "to know which Kodi versions are supported.", 0) xbmcgui.Dialog().ok( heading="Emby Warning", line1=( "Cancelling the database syncing process. " "Current Kodi versoin: %s is unsupported. " "Please verify your logs for more info." % xbmc.getInfoLabel('System.BuildVersion'))) break # Run start up sync self.logMsg("Db version: %s" % utils.settings('dbCreatedWithVersion'), 0) self.logMsg("SyncDatabase (started)", 1) startTime = datetime.now() librarySync = self.startSync() elapsedTime = datetime.now() - startTime self.logMsg( "SyncDatabase (finished in: %s) %s" % (str(elapsedTime).split('.')[0], librarySync), 1) # Only try the initial sync once per kodi session regardless # This will prevent an infinite loop in case something goes wrong. startupComplete = True # Process updates if utils.window('emby_dbScan') != "true": self.incrementalSync() if (utils.window('emby_onWake') == "true" and utils.window('emby_online') == "true"): # Kodi is waking up # Set in kodimonitor.py utils.window('emby_onWake', clear=True) if utils.window('emby_syncRunning') != "true": self.logMsg("SyncDatabase onWake (started)", 0) librarySync = self.startSync() self.logMsg("SyncDatabase onWake (finished) %s", librarySync, 0) if self.stop_thread: # Set in service.py self.logMsg("Service terminated thread.", 2) break if monitor.waitForAbort(1): # Abort was requested while waiting. We should exit break self.logMsg("###===--- LibrarySync Stopped ---===###", 0)
def run_autoencoder2(experiment, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path, prev_model_path, code_size=1250, prev_code_size=2500): if os.path.isfile(model_path) or \ os.path.isfile(model_path + ".meta"): return prev_model = ae( X_train.shape[1], prev_code_size, corruption=0.0, # Disable corruption for conversion enc=tf.nn.tanh, dec=None) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) saver = tf.train.Saver(prev_model["params"], write_version=tf.train.SaverDef.V2) if os.path.isfile(prev_model_path): saver.restore(sess, prev_model_path) X_train = sess.run(prev_model["encode"], feed_dict={prev_model["input"]: X_train}) X_valid = sess.run(prev_model["encode"], feed_dict={prev_model["input"]: X_valid}) X_test = sess.run(prev_model["encode"], feed_dict={prev_model["input"]: X_test}) del prev_model reset() learning_rate = 0.0001 corruption = 0.9 ae_enc = tf.nn.tanh ae_dec = None training_iters = 2000 batch_size = 10 n_classes = 2 model = ae(prev_code_size, code_size, corruption=corruption, enc=ae_enc, dec=ae_dec) optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize( model["cost"]) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) saver = tf.train.Saver(model["params"], write_version=tf.train.SaverDef.V2) prev_costs = np.array([9999999999] * 3) for epoch in range(training_iters): batches = range(len(X_train) / batch_size) costs = np.zeros((len(batches), 3)) for ib in batches: from_i = ib * batch_size to_i = (ib + 1) * batch_size batch_xs, batch_ys = X_train[from_i:to_i], y_train[from_i:to_i] _, cost_train = sess.run([optimizer, model["cost"]], feed_dict={model["input"]: batch_xs}) cost_valid = sess.run(model["cost"], feed_dict={model["input"]: X_valid}) cost_test = sess.run(model["cost"], feed_dict={model["input"]: X_test}) costs[ib] = [cost_train, cost_valid, cost_test] costs = costs.mean(axis=0) cost_train, cost_valid, cost_test = costs print format_config( "Exp={experiment}, Model=ae2, Iter={epoch:5d}, Cost={cost_train:.6f} {cost_valid:.6f} {cost_test:.6f}", { "experiment": experiment, "epoch": epoch, "cost_train": cost_train, "cost_valid": cost_valid, "cost_test": cost_test, }), if cost_valid < prev_costs[1]: print "Saving better model" saver.save(sess, model_path) prev_costs = costs else: print
def run_nn(hdf5, experiment, code_size_1, code_size_2, code_size_3): exp_storage = hdf5["experiments"]["cc200_whole"] #exp_storage = hdf5["experiments"]["aal_whole"] #exp_storage = hdf5["experiments"]["dosenbach160_whole"] for fold in exp_storage: experiment_cv = format_config("{experiment}_{fold}", { "experiment": experiment, "fold": fold, }) X_train, y_train, \ X_valid, y_valid, \ X_test, y_test,test_pid = load_fold(hdf5["patients"], exp_storage, fold) ae1_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt", { "experiment": experiment_cv, }) ae2_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt", { "experiment": experiment_cv, }) ae3_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt", { "experiment": experiment_cv, }) nn_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_mlp.ckpt", { "experiment": experiment_cv, }) # ae1_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt", { # "experiment": experiment_cv, # }) # ae2_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt", { # "experiment": experiment_cv, # }) # ae3_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt", { # "experiment": experiment_cv, # }) # nn_model_path = format_config("./data/aal_tichu_2500_1250_625/{experiment}_mlp.ckpt", { # "experiment": experiment_cv, # }) # ae1_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt", { # "experiment": experiment_cv, # }) # ae2_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt", { # "experiment": experiment_cv, # }) # ae3_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt", { # "experiment": experiment_cv, # }) # nn_model_path = format_config("./data/dosenbach160_tichu_2500_1250_625/{experiment}_mlp.ckpt", { # "experiment": experiment_cv, # }) reset() # Run first autoencoder run_autoencoder1(experiment_cv, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path=ae1_model_path, code_size=code_size_1) reset() # Run second autoencoder run_autoencoder2(experiment_cv, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path=ae2_model_path, prev_model_path=ae1_model_path, prev_code_size=code_size_1, code_size=code_size_2) reset() run_autoencoder3(experiment_cv, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path=ae3_model_path, prev_model_path=ae2_model_path, prev_code_size=code_size_2, code_size=code_size_3) reset() # Run multilayer NN with pre-trained autoencoders run_finetuning(experiment_cv, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path=nn_model_path, prev_model_1_path=ae1_model_path, prev_model_2_path=ae2_model_path, prev_model_3_path=ae3_model_path, code_size_1=code_size_1, code_size_2=code_size_2, code_size_3=code_size_3)
def reset_parameters(self): reset(self.nn) uniform(self.in_channels, self.root) uniform(self.in_channels, self.bias)
def update_likes(bot, update): utils.reset() update.message.reply_text('Успешно')
def run_internal(self): dialog = xbmcgui.Dialog() startupComplete = False log.warn("---===### Starting LibrarySync ###===---") # Verify database structure, otherwise create it. self._verify_emby_database() while not self.monitor.abortRequested(): # In the event the server goes offline while self.suspend_thread: # Set in service.py if self.monitor.waitForAbort(5): # Abort was requested while waiting. We should exit break if (window('emby_dbCheck') != "true" and settings('SyncInstallRunDone') == "true"): # Verify the validity of the database embyconn = utils.kodiSQL('emby') embycursor = embyconn.cursor() emby_db = embydb.Embydb_Functions(embycursor) currentVersion = emby_db.get_version() ###$ Begin migration $### if not currentVersion: currentVersion = emby_db.get_version( settings('dbCreatedWithVersion') or self.clientInfo.get_version()) embyconn.commit() log.info("Migration of database version completed") ###$ End migration $### embycursor.close() window('emby_version', value=currentVersion) minVersion = window('emby_minDBVersion') uptoDate = self.compareDBVersion(currentVersion, minVersion) if not uptoDate: log.warn( "Database version out of date: %s minimum version required: %s" % (currentVersion, minVersion)) resp = dialog.yesno(lang(29999), lang(33022)) if not resp: log.warn( "Database version is out of date! USER IGNORED!") dialog.ok(lang(29999), lang(33023)) else: utils.reset() break window('emby_dbCheck', value="true") if not startupComplete: # Verify the video database can be found videoDb = utils.getKodiVideoDBPath() if not xbmcvfs.exists(videoDb): # Database does not exists log.error("The current Kodi version is incompatible " "with the Emby for Kodi add-on. Please visit " "https://github.com/MediaBrowser/Emby.Kodi/wiki " "to know which Kodi versions are supported.") dialog.ok(heading=lang(29999), line1=lang(33024)) break # Run start up sync log.warn("Database version: %s", window('emby_version')) log.info("SyncDatabase (started)") startTime = datetime.now() librarySync = self.startSync() elapsedTime = datetime.now() - startTime log.info("SyncDatabase (finished in: %s) %s" % (str(elapsedTime).split('.')[0], librarySync)) # Add other servers at this point # TODO: re-add once plugin listing is created # self.user.load_connect_servers() # Only try the initial sync once per kodi session regardless # This will prevent an infinite loop in case something goes wrong. startupComplete = True # Process updates if window('emby_dbScan') != "true" and window( 'emby_shouldStop') != "true": self.incrementalSync() if window('emby_onWake') == "true" and window( 'emby_online') == "true": # Kodi is waking up # Set in kodimonitor.py window('emby_onWake', clear=True) if window('emby_syncRunning') != "true": log.info("SyncDatabase onWake (started)") librarySync = self.startSync() log.info("SyncDatabase onWake (finished) %s" % librarySync) if self.stop_thread: # Set in service.py log.debug("Service terminated thread.") break if self.monitor.waitForAbort(1): # Abort was requested while waiting. We should exit break log.warn("###===--- LibrarySync Stopped ---===###")
def main(): ################ load ################### if os.path.exists('D:/Software/GamaWorkspace/Python/weight/actor.pkl'): actor = Actor(state_size, action_size).to(device) actor.load_state_dict(torch.load('D:/Software/GamaWorkspace/Python/weight/actor.pkl')) print('Actor Model loaded') else: actor = Actor(state_size, action_size).to(device) if os.path.exists('D:/Software/GamaWorkspace/Python/weight/critic.pkl'): critic = Critic(state_size, action_size).to(device) critic.load_state_dict(torch.load('D:/Software/GamaWorkspace/Python/weight/critic.pkl')) print('Critic Model loaded') else: critic = Critic(state_size, action_size).to(device) print("Waiting for GAMA...") ################### initialization ######################## reset() optimizerA = optim.Adam(actor.parameters(), lr, betas=(0.95, 0.999))#optim.Adam(actor.parameters()) optimizerC = optim.Adam(critic.parameters(), lr, betas=(0.95, 0.999))#optim.Adam(critic.parameters()) episode = 0 test = "GAMA" state,reward,done,time_pass,over = GAMA_connect(test) print("done:",done,"timepass:"******"acceleration: ",action.cpu().numpy())#,"action.cpu().numpy()",type(float(action.cpu().numpy())) to_GAMA = [[1,float(action.cpu().numpy()*10)]] #行 np.savetxt(from_python_1,to_GAMA,delimiter=',') np.savetxt(from_python_2,to_GAMA,delimiter=',') #前回の報酬 rewards.append(torch.tensor([reward], dtype=torch.float, device=device)) #contains the last masks.append(torch.tensor([1-done], dtype=torch.float, device=device)) #over-0; otherwise-1 contains the last log_prob = log_prob.unsqueeze(0) #log_prob = dist.log_prob(action).unsqueeze(0) # entropy += dist.entropy().mean() log_probs.append(log_prob) values.append(value) entropy += entropy # 終わり elif done == 1: print("restart acceleration: 0") to_GAMA = [[1,0]] np.savetxt(from_python_1,to_GAMA,delimiter=',') np.savetxt(from_python_2,to_GAMA,delimiter=',') #先传后计算 rewards.append(torch.tensor([reward], dtype=torch.float, device=device)) #contains the last masks.append(torch.tensor([1-done], dtype=torch.float, device=device)) #over-0; otherwise-1 contains the last total_reward = sum(rewards) total_rewards.append(total_reward) last_state = torch.FloatTensor(state).to(device) last_value = critic(last_state) returns = compute_returns(last_value, rewards, masks) values_next = returns[1:]#values[1:] values_next.append(torch.tensor([0], dtype=torch.float, device=device)) log_probs = torch.cat(log_probs,1).squeeze() #Concatenates the given sequence of seq tensors in the given dimension. returns = torch.cat(returns).detach() values = torch.cat(values) values_next = torch.cat(values_next) rewards = torch.cat(rewards) # TD:r(s) + v(s+1) - v(s) #rewards.detach() + values_next - values r(s) MC: returns.detach() - values??? advantage = returns.detach() - values actor_loss = -(log_probs * advantage.detach()).mean() loss = advantage.pow(2).sum() loss.detach() critic_loss = (returns.detach() - values).pow(2).mean() optimizerA.zero_grad() optimizerC.zero_grad() actor_loss.backward() critic_loss.backward() optimizerA.step() optimizerC.step() print("--------------------------Net_Trained-------------------------------") print('--------------------------Iteration:',episode,'over--------------------------------') episode += 1 log_probs = [] values = [] rewards = [] masks = [] torch.save(actor.state_dict(), 'D:/Software/GamaWorkspace/Python/weight/actor.pkl') torch.save(critic.state_dict(), 'D:/Software/GamaWorkspace/Python/weight/critic.pkl') #print("entropy: ",entropy,"total_rewards:",total_rewards) entropys.append(entropy) total_loss.append(loss) if(episode!=0): cross_loss_curve(total_loss,total_rewards) loss = 0 if episode > 90 : new_lr = lr * (0.92 ** ((episode-80) // 10)) optimizerA = optim.Adam(actor.parameters(), new_lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), new_lr, betas=(0.95, 0.999)) #最初の時 else: print('Iteration:',episode) state = torch.FloatTensor(state).to(device) value = critic(state) #dist, # now is a tensoraction = dist.sample() action,log_prob,entropy = actor(state) print("acceleration: ",float(action.cpu().numpy()*10)) to_GAMA = [[1,action.cpu().numpy()]] np.savetxt(from_python_1,to_GAMA,delimiter=',') np.savetxt(from_python_1,to_GAMA,delimiter=',') log_prob = log_prob.unsqueeze(0) #log_prob = dist.log_prob(action).unsqueeze(0) #entropy += dist.entropy().mean() log_probs.append(log_prob) values.append(value) entropy += entropy state,reward,done,time_pass,over = GAMA_connect(test) return None #[action,log_prob_return,value]
def nn_results(hdf5, experiment, code_size_1, code_size_2, code_size_3): exp_storage = hdf5["experiments"]['cc200_whole'] experiment = "cc200_whole" print exp_storage n_classes = 2 results = [] list = [''] list2 = [] for fold in exp_storage: experiment_cv = format_config("{experiment}_{fold}", { "experiment": experiment, "fold": fold, }) print "experiment_cv" print fold X_train, y_train, \ X_valid, y_valid, \ X_test, y_test,test_pid = load_fold(hdf5["patients"], exp_storage, fold) list.append(test_pid) print "X_train" print X_train.shape y_test = np.array([to_softmax(n_classes, y) for y in y_test]) ae1_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-1.ckpt", { "experiment": experiment_cv, }) ae2_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-2.ckpt", { "experiment": experiment_cv, }) ae3_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_autoencoder-3.ckpt", { "experiment": experiment_cv, }) nn_model_path = format_config( "./data/cc200_tichu_2500_1250_625/{experiment}_mlp.ckpt", { "experiment": experiment_cv, }) try: model = nn(X_test.shape[1], n_classes, [ { "size": 2500, "actv": tf.nn.tanh }, { "size": 1250, "actv": tf.nn.tanh }, { "size": 625, "actv": tf.nn.tanh }, ]) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) saver = tf.train.Saver(model["params"]) print "savernn_model_path" print nn_model_path saver.restore(sess, nn_model_path) output = sess.run(model["output"], feed_dict={ model["input"]: X_test, model["dropouts"][0]: 1.0, model["dropouts"][1]: 1.0, model["dropouts"][2]: 1.0, }) np.set_printoptions(suppress=True) y_score = output[:, 1] print "y_score" print y_score y_pred = np.argmax(output, axis=1) print "y_pred" print y_pred print "output" hang = output.shape[0] lie = output.shape[1] print hang print lie for tt in range(hang): for xx in range(lie): output[tt][xx] = round(output[tt][xx], 4) output[tt][xx] = str(output[tt][xx]) aa = output[:, 0] print type(aa) list2.append(output) list.append(y_pred) print "-------------------------------------" y_true = np.argmax(y_test, axis=1) list.append(y_true) print "y_true" print y_true auc_score = roc_auc_score(y_true, y_score) print auc_score [[TN, FP], [FN, TP]] = confusion_matrix(y_true, y_pred, labels=[0, 1]).astype(float) accuracy = (TP + TN) / (TP + TN + FP + FN) print(TP) print(TN) print(FP) print(FN) specificity = TN / (FP + TN) precision = TP / (TP + FP) sensivity = recall = TP / (TP + FN) fscore = 2 * TP / (2 * TP + FP + FN) results.append([ accuracy, precision, recall, fscore, sensivity, specificity, auc_score ]) finally: reset() workbook = xlwt.Workbook(encoding='utf-8') booksheet = workbook.add_sheet('Sheet 1', cell_overwrite_ok=True) wb = xlwt.Workbook(encoding='utf-8') worksheet = wb.add_sheet('Sheet 1', cell_overwrite_ok=True) DATA = list print list2 for i, row in enumerate(DATA): for j, col in enumerate(row): booksheet.write(j, i, col) # workbook.save('./data/dos_tichu_2500_1250_625_xlst.xls') return [experiment] + np.mean(results, axis=0).tolist()
from mathutils import Vector import animation import objects import utils import render # reset scene utils.reset() # determine grey horizon color bpy.data.worlds["World"].horizon_color = [0.04, 0.04, 0.04] # create some common objects scene = bpy.context.scene camera_rotation_n_frames = 100 # ─── TITLE ───────────────────────────────────────────────────────────────────── print("STAGE: title") stage_title = bpy.data.objects.new("stage_title", None) stage_title.rotation_euler = Vector((0, 0, np.pi / 2)) stage_title.location = Vector((-20, 0, 0)) scene.objects.link(stage_title) stage_title["start"] = 0 # add camera and initially look at title stage camera = utils.camera((0, 0, 0), lens=20)
def __init__(self): log.debug('Full sys.argv received: %s' % argv) # Parse parameters params = dict(parse_qsl(argv[2][1:])) mode = params.get('mode', '') itemid = params.get('id', '') if mode == 'play': self.play() elif mode == 'plex_node': self.play() elif mode == 'ondeck': entrypoint.getOnDeck(itemid, params.get('type'), params.get('tagname'), int(params.get('limit'))) elif mode == 'recentepisodes': entrypoint.getRecentEpisodes(itemid, params.get('type'), params.get('tagname'), int(params.get('limit'))) elif mode == 'nextup': entrypoint.getNextUpEpisodes(params['tagname'], int(params['limit'])) elif mode == 'inprogressepisodes': entrypoint.getInProgressEpisodes(params['tagname'], int(params['limit'])) elif mode == 'browseplex': entrypoint.browse_plex(key=params.get('key'), plex_section_id=params.get('id')) elif mode == 'getsubfolders': entrypoint.GetSubFolders(itemid) elif mode == 'watchlater': entrypoint.watchlater() elif mode == 'channels': entrypoint.channels() elif mode == 'settings': executebuiltin('Addon.OpenSettings(%s)' % v.ADDON_ID) elif mode == 'enterPMS': entrypoint.enterPMS() elif mode == 'reset': reset() elif mode == 'togglePlexTV': entrypoint.togglePlexTV() elif mode == 'resetauth': entrypoint.resetAuth() elif mode == 'passwords': passwordsXML() elif mode == 'switchuser': entrypoint.switchPlexUser() elif mode in ('manualsync', 'repair'): if window('plex_online') != 'true': # Server is not online, do not run the sync dialog('ok', lang(29999), lang(39205)) log.error('Not connected to a PMS.') else: if mode == 'repair': window('plex_runLibScan', value='repair') log.info('Requesting repair lib sync') elif mode == 'manualsync': log.info('Requesting full library scan') window('plex_runLibScan', value='full') elif mode == 'texturecache': window('plex_runLibScan', value='del_textures') elif mode == 'chooseServer': entrypoint.chooseServer() elif mode == 'refreshplaylist': log.info('Requesting playlist/nodes refresh') window('plex_runLibScan', value='views') elif mode == 'deviceid': self.deviceid() elif mode == 'fanart': log.info('User requested fanarttv refresh') window('plex_runLibScan', value='fanart') elif '/extrafanart' in argv[0]: plexpath = argv[2][1:] plexid = itemid entrypoint.getExtraFanArt(plexid, plexpath) entrypoint.getVideoFiles(plexid, plexpath) # Called by e.g. 3rd party plugin video extras elif ('/Extras' in argv[0] or '/VideoFiles' in argv[0] or '/Extras' in argv[2]): plexId = itemid or None entrypoint.getVideoFiles(plexId, params) else: entrypoint.doMainListing(content_type=params.get('content_type'))
def nn_results(hdf5, experiment, code_size_1, code_size_2): exp_storage = hdf5["experiments"][experiment] n_classes = 2 results = [] for fold in exp_storage: experiment_cv = format_config("{experiment}_{fold}", { "experiment": experiment, "fold": fold, }) X_train, y_train, \ X_valid, y_valid, \ X_test, y_test = load_fold(hdf5["patients"], exp_storage, fold) y_test = np.array([to_softmax(n_classes, y) for y in y_test]) ae1_model_path = format_config( "./data/models/{experiment}_autoencoder-1.ckpt", { "experiment": experiment_cv, }) ae2_model_path = format_config( "./data/models/{experiment}_autoencoder-2.ckpt", { "experiment": experiment_cv, }) nn_model_path = format_config("./data/models/{experiment}_mlp.ckpt", { "experiment": experiment_cv, }) try: model = nn(X_test.shape[1], n_classes, [ { "size": 1000, "actv": tf.nn.tanh }, { "size": 600, "actv": tf.nn.tanh }, ]) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) saver = tf.train.Saver(model["params"]) saver.restore(sess, nn_model_path) output = sess.run(model["output"], feed_dict={ model["input"]: X_test, model["dropouts"][0]: 1.0, model["dropouts"][1]: 1.0, }) print(output) y_pred = np.argmax(output, axis=1) y_true = np.argmax(y_test, axis=1) [[TN, FP], [FN, TP]] = confusion_matrix(y_true, y_pred, labels=[0, 1]).astype(float) accuracy = (TP + TN) / (TP + TN + FP + FN) specificity = TN / (FP + TN) precision = TP / (TP + FP) sensivity = recall = TP / (TP + FN) fscore = 2 * TP / (2 * TP + FP + FN) results.append([ accuracy, precision, recall, fscore, sensivity, specificity ]) finally: reset() return [experiment] + np.mean(results, axis=0).tolist()
from packet import Packet from random import randint from matplotlib import pyplot as plt from utils import reset, count_wins, report from globals import networks, SIZE, NTRIALS, PTIMES, STRATEGIES NTIME_STEPS = 200 NSERVERS = SIZE**2 win_freqs = {strategy: [] for strategy in STRATEGIES} if __name__ == '__main__': # Run SLB model simulation for ptime in PTIMES: for i in xrange(NTRIALS): reset(networks) for j in xrange(NTIME_STEPS): loc = randint(0, NSERVERS - 1) pkt = Packet('id-%d' % (j), ptime) for sim_obj in networks: network = sim_obj['obj'] network.step() network.add(pkt, loc) sim_obj['dat'][ptime][i] += network.latency() # Count and report win frequencies for ptime in PTIMES: win_counts = {strategy: 0 for strategy in STRATEGIES} count_wins(networks, ptime, win_counts, NTRIALS) report(win_counts, ptime, NTRIALS) for strategy, count in win_counts.iteritems():
def main(): ################ load ################### actor_path = os.path.abspath( os.curdir) + '/PPO_Mixedinput_Navigation_Model/weight/AC_TD0_actor.pkl' critic_path = os.path.abspath( os.curdir ) + '/PPO_Mixedinput_Navigation_Model/weight/AC_TD0_critic.pkl' if os.path.exists(actor_path): actor = Actor(state_size, action_size).to(device) actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') else: actor = Actor(state_size, action_size).to(device) if os.path.exists(critic_path): critic = Critic(state_size, action_size).to(device) critic.load_state_dict(torch.load(critic_path)) print('Critic Model loaded') else: critic = Critic(state_size, action_size).to(device) critic_next = Critic(state_size, action_size).to(device) critic_next.load_state_dict(critic.state_dict()) print("Waiting for GAMA...") ################### initialization ######################## reset() episode = 1257 lr = 0.0001 sample_lr = [ 0.0001, 0.00009, 0.00008, 0.00007, 0.00006, 0.00005, 0.00004, 0.00003, 0.00002, 0.00001, 0.000009, 0.000008, 0.000007, 0.000006, 0.000005, 0.000004, 0.000003, 0.000002, 0.000001 ] if episode > 50: #50 100 try: lr = sample_lr[int(episode // 50)] except (IndexError): lr = 0.000001 optimizerA = optim.Adam(actor.parameters(), lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), lr, betas=(0.95, 0.999)) test = "GAMA" state, reward, done, time_pass, over = GAMA_connect(test) #connect print("done:", done, "timepass:"******"----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 log_probs = [] values = [] rewards = [] masks = [] loss_sum = sum(loss).cpu().detach().numpy() total_loss.append(loss_sum) cross_loss_curve(loss_sum.squeeze(0), total_reward, save_curve_pic, save_critic_loss, save_reward) #total_loss,total_rewards loss = [] memory.clear_memory() if episode > 50: #50 100 try: lr = sample_lr[int(episode // 50)] except (IndexError): lr = 0.000001 optimizerA = optim.Adam(actor.parameters(), lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), lr, betas=(0.95, 0.999)) torch.save(actor.state_dict(), actor_path) torch.save(critic.state_dict(), critic_path) #最初の時 else: print('Iteration:', episode, "lr:", lr) state = np.reshape(state, (1, len(state))) #xxx state_img = generate_img() tensor_cv = torch.from_numpy(np.transpose( state_img, (2, 0, 1))).double().to(device) state = torch.DoubleTensor(state).reshape(1, state_size).to(device) for _ in range(3): memory.states.append(state) memory.states_img.append(tensor_cv) state = torch.stack(memory.states).to(device).detach() ### tensor_cv = torch.stack(memory.states_img).to(device).detach() value = critic( state, tensor_cv) #dist, # now is a tensoraction = dist.sample() action, log_prob, entropy = actor(state, tensor_cv) print("acceleration: ", action.cpu().numpy()) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) log_prob = log_prob.unsqueeze(0) entropy += entropy state, reward, done, time_pass, over = GAMA_connect(test) return None
def run_autoencoder2(experiment, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path, prev_model_path, code_size=600, prev_code_size=1000): """ Run the second autoencoder. It takes the dimensionality from first autoencoder and compresses it into the new `code_size` Firstly, we need to convert original data to the new projection from autoencoder 1. """ if os.path.isfile(model_path) or \ os.path.isfile(model_path + ".meta"): return # tf.disable_v2_behavior() # Convert training, validation and test set to the new representation prev_model = ae( X_train.shape[1], prev_code_size, corruption=0.0, # Disable corruption for conversion enc=tf.nn.tanh, dec=None) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) saver = tf.train.Saver(prev_model["params"], write_version=tf.train.SaverDef.V2) if os.path.isfile(prev_model_path): saver.restore(sess, prev_model_path) X_train = sess.run(prev_model["encode"], feed_dict={prev_model["input"]: X_train}) X_valid = sess.run(prev_model["encode"], feed_dict={prev_model["input"]: X_valid}) X_test = sess.run(prev_model["encode"], feed_dict={prev_model["input"]: X_test}) del prev_model reset() # Hyperparameters learning_rate = 0.0001 corruption = 0.9 ae_enc = tf.nn.tanh ae_dec = None training_iters = 2000 batch_size = 10 n_classes = 2 # Load model model = ae(prev_code_size, code_size, corruption=corruption, enc=ae_enc, dec=ae_dec) # Use GD for optimization of model cost optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize( model["cost"]) # Initialize Tensorflow session init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) # Define model saver saver = tf.train.Saver(model["params"], write_version=tf.train.SaverDef.V2) # Initialize with an absurd cost for model selection prev_costs = np.array([9999999999] * 3) # Iterate Epochs for epoch in range(training_iters): # Break training set into batches batches = range(int(len(X_train) / batch_size)) costs = np.zeros((len(batches), 3)) for ib in batches: # Compute start and end of batch from training set data array from_i = ib * batch_size to_i = (ib + 1) * batch_size # Select current batch batch_xs, batch_ys = X_train[from_i:to_i], y_train[from_i:to_i] # Run optimization and retrieve training cost _, cost_train = sess.run([optimizer, model["cost"]], feed_dict={model["input"]: batch_xs}) # Compute validation cost cost_valid = sess.run(model["cost"], feed_dict={model["input"]: X_valid}) # Compute test cost cost_test = sess.run(model["cost"], feed_dict={model["input"]: X_test}) costs[ib] = [cost_train, cost_valid, cost_test] # Compute the average costs from all batches costs = costs.mean(axis=0) cost_train, cost_valid, cost_test = costs # Pretty print training info print( "Exp={experiment}, Model=ae2, Iter={epoch:5d}, Cost={cost_train:.6f} {cost_valid:.6f} {cost_test:.6f}", { "experiment": experiment, "epoch": epoch, "cost_train": cost_train, "cost_valid": cost_valid, "cost_test": cost_test, }) # Save better model if optimization achieves a lower cost if cost_valid < prev_costs[1]: print("Saving better model") saver.save(sess, model_path) prev_costs = costs else: print
def run_nn(hdf5, experiment, code_size_1, code_size_2): # tf.disable_v2_behavior() exp_storage = hdf5["experiments"][experiment] for fold in exp_storage: experiment_cv = format_config("{experiment}_{fold}", { "experiment": experiment, "fold": fold, }) X_train, y_train, \ X_valid, y_valid, \ X_test, y_test = load_fold(hdf5["patients"], exp_storage, fold) ae1_model_path = format_config( "./data/models/{experiment}_autoencoder-1.ckpt", { "experiment": experiment_cv, }) ae2_model_path = format_config( "./data/models/{experiment}_autoencoder-2.ckpt", { "experiment": experiment_cv, }) nn_model_path = format_config("./data/models/{experiment}_mlp.ckpt", { "experiment": experiment_cv, }) reset() # Run first autoencoder run_autoencoder1(experiment_cv, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path=ae1_model_path, code_size=code_size_1) reset() # Run second autoencoder run_autoencoder2(experiment_cv, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path=ae2_model_path, prev_model_path=ae1_model_path, prev_code_size=code_size_1, code_size=code_size_2) reset() # Run multilayer NN with pre-trained autoencoders run_finetuning(experiment_cv, X_train, y_train, X_valid, y_valid, X_test, y_test, model_path=nn_model_path, prev_model_1_path=ae1_model_path, prev_model_2_path=ae2_model_path, code_size_1=code_size_1, code_size_2=code_size_2)
def main(): ################ load ################### actor_path = os.path.abspath( os.curdir) + '/Generate_Traffic_Flow_MAS_RL/weight/AC_TD2_actor.pkl' if os.path.exists(actor_path): actor = Actor(state_size, action_size).to(device) actor.load_state_dict(torch.load(actor_path)) print('Actor Model loaded') else: actor = Actor(state_size, action_size).to(device) print("Waiting for GAMA...") ################### initialization ######################## reset() Using_LSTM = False test = "GAMA" N_agent = 20 list_hidden = [] count = 0 ################## start ######################### state = GAMA_connect(test) print("Connected") while True: if Using_LSTM == False: state = [ torch.DoubleTensor(elem).reshape(1, state_size).to(device) for elem in state ] state = torch.stack(state).to(device).detach() tensor_cv = generate_img() tensor_cv = [ torch.from_numpy(np.transpose(elem, (2, 0, 1))).double().to(device) / 255 for elem in tensor_cv ] tensor_cv = torch.stack(tensor_cv).to(device).detach() action, h_state_cv_a, h_state_n_a = actor(state, tensor_cv) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) else: if len(list_hidden) < N_agent: state = [ torch.DoubleTensor(elem).reshape(1, state_size).to(device) for elem in state ] state = torch.stack(state).to(device).detach() tensor_cv = generate_img() tensor_cv = [ torch.from_numpy(np.transpose( elem, (2, 0, 1))).double().to(device) / 255 for elem in tensor_cv ] tensor_cv = torch.stack(tensor_cv).to(device).detach() action, h_state_cv_a, h_state_n_a = actor(state, tensor_cv) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) list_hidden.append(Memory(h_state_cv_a, h_state_n_a)) count += 1 else: state = [ torch.DoubleTensor(elem).reshape(1, state_size).to(device) for elem in state ] state = torch.stack(state).to(device).detach() tensor_cv = generate_img() tensor_cv = [ torch.from_numpy(np.transpose( elem, (2, 0, 1))).double().to(device) / 255 for elem in tensor_cv ] tensor_cv = torch.stack(tensor_cv).to(device).detach() action, h_state_cv_a, h_state_n_a = actor( state, tensor_cv, list_hidden[count % N_agent].h_state_cv_a, list_hidden[count % N_agent].h_state_n_a) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) list_hidden[count % N_agent].set_hidden( h_state_cv_a, h_state_n_a) count += 1 state = GAMA_connect(test) return None
#################################### write_MAC_cmd = ('ets', 'PPWR=2,' + mac) read_MAC_cmd = ('ets', 'PPRE=2') if check_ser_port is True: # Writes the input MAC to DUT utils.debug('Writing input MAC to DUT') out_write = serial_com.write_cmd(write_MAC_cmd) serial_com.write_cmd('q') time.sleep(0.05) # Resets DUT utils.debug('Resetting DUT ...') utils.reset(os.environ['nrfjprog_PATH']) time.sleep(5) # Reads MAC of DUT utils.debug('Reading MAC from DUT') out_read = serial_com.write_cmd(read_MAC_cmd) serial_com.write_cmd('q') if mac in out_read: utils.debug('Succefully writing input MAC to DUT') else: utils.debug('Writing MAC to DUT failed') else: utils.debug('Serial port is not open') ser.open()
def main(): ################ load ################### if os.path.exists( 'D:/Software/PythonWork/GAMA_python/A2C-TD-single-car-intersection/weight/actor.pkl' ): actor = Actor(state_size, action_size).to(device) actor.load_state_dict( torch.load( 'D:/Software/PythonWork/GAMA_python/A2C-TD-single-car-intersection/weight/actor.pkl' )) print('Actor Model loaded') else: actor = Actor(state_size, action_size).to(device) if os.path.exists( 'D:/Software/PythonWork/GAMA_python/A2C-TD-single-car-intersection/weight/critic.pkl' ): critic = Critic(state_size, action_size).to(device) critic.load_state_dict( torch.load( 'D:/Software/PythonWork/GAMA_python/A2C-TD-single-car-intersection/weight/critic.pkl' )) print('Critic Model loaded') else: critic = Critic(state_size, action_size).to(device) print("Waiting for GAMA...") ################### initialization ######################## reset() lr = 0.00007 optimizerA = optim.Adam(actor.parameters(), lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), lr, betas=(0.95, 0.999)) episode = 0 test = "GAMA" state, reward, done, time_pass, over = GAMA_connect(test) #connect print("done:", done, "timepass:"******"restart acceleration: 0") send_to_GAMA([[1, 0]]) #先传后计算 rewards.append(reward) #contains the last reward = torch.tensor([reward], dtype=torch.float, device=device) rewards.append(reward) #contains the last total_reward = sum(rewards) total_rewards.append(total_reward) #state = torch.FloatTensor(state).reshape(1,4).to(device) #last_value= critic(state) with torch.autograd.set_detect_anomaly(True): advantage = reward.detach( ) - value #+ last_value 最后一回的V(s+1) = 0 actor_loss = -(log_prob * advantage.detach()) print("actor_loss, ", actor_loss, " size", actor_loss.dim()) critic_loss = (reward.detach() - value).pow(2) #+ last_value lstm_loss = critic_loss optimizerA.zero_grad() optimizerC.zero_grad() critic_loss.backward(retain_graph=True) actor_loss.backward(retain_graph=True) loss.append(critic_loss) optimizerA.step() optimizerC.step() print( "----------------------------------Net_Trained---------------------------------------" ) print('--------------------------Iteration:', episode, 'over--------------------------------') episode += 1 log_probs = [] values = [] rewards = [] masks = [] torch.save( actor.state_dict(), 'D:/Software/PythonWork/GAMA_python/A2C-TD-single-car-intersection/weight/actor.pkl' ) torch.save( critic.state_dict(), 'D:/Software/PythonWork/GAMA_python/A2C-TD-single-car-intersection/weight/critic.pkl' ) loss_sum = sum(loss) total_loss.append(loss_sum) cross_loss_curve(total_loss, total_rewards) loss = [] if episode > 50: #50 lr = 0.0002 if episode > 115: lr = 0.0001 new_lr = lr * (0.94**((episode - 40) // 10)) #40 optimizerA = optim.Adam(actor.parameters(), new_lr, betas=(0.95, 0.999)) optimizerC = optim.Adam(critic.parameters(), new_lr, betas=(0.95, 0.999)) #最初の時 else: print('Iteration:', episode) state = np.reshape(state, (1, len(state))) #xxx state = torch.FloatTensor(state).reshape(1, 4).to(device) value = critic( state) #dist, # now is a tensoraction = dist.sample() action, log_prob, entropy = actor(state) print("acceleration: ", action.cpu().numpy()) send_to_GAMA([[1, float(action.cpu().numpy() * 10)]]) log_prob = log_prob.unsqueeze(0) entropy += entropy state, reward, done, time_pass, over = GAMA_connect(test) return None
def reset(): return utils.reset()