def main(argv=None): print('Loading data') x = load_data() print('Finished!') print('Starting training') train(x)
def main(args): with tf.Session() as sess: env = make_env.make_env('simple_tag') n = env.n actors = [] critics = [] exploration_noise = [] observation_dim = [] action_dim = [] total_action_dim = 0 for i in range(n): total_action_dim = total_action_dim + env.action_space[i].n for i in range(n): observation_dim.append(env.observation_space[i].shape[0]) action_dim.append(env.action_space[i].n) # assuming discrete action space here -> otherwise change to something like env.action_space[i].shape[0] actors.append(ActorNetwork(sess,observation_dim[i],action_dim[i],float(args['actor_lr']),float(args['tau']))) critics.append(CriticNetwork(sess,n,observation_dim[i],total_action_dim,float(args['actor_lr']),float(args['tau']),float(args['gamma']))) exploration_noise.append(OUNoise(mu = np.zeros(action_dim[i]))) #if args['use_gym_monitor']: # if not args['render_env']: # envMonitor = wrappers.Monitor(env, args['monitor_dir'], video_callable=False, force=True) # else: # envMonitor = wrappers.Monitor(env, args['monitor_dir'], force=True) train(sess,env,args,actors,critics,exploration_noise)
def main(argv=None): print('load data') mnist = load_data() print('Finished!') print('Start training!') train(mnist)
def main(): config = sysconfig() print(config.Train_set_path) IS_Training = True if IS_Training: train(config) else: test(config)
def main(argv=None): print('This is to build a simple RNN.') print('Loading data') x = load_data() print('Finished!') print('Starting training') train(x)
def main(argv=None): print( 'This is to pretrain a shallow neural network using autoencoder or restricted boltzmann machine.' 'There are two options.' '1 -> pretrain_with_RBM' '2 -> pretrain_with_AE') print('Loading data') x = load_data() print('Finished!') print() option = 'pretrain_with_RBM' print('Starting training') train(x, option)
def main(args): print(args) train(task=args.task, modelname=args.model, data_dir=args.dataset, dim=args.dim, batch=args.batch, lr=args.lr, max_epoch=args.max_epoch, gamma=args.gamma, lossname=args.loss, negsample_num=args.eta, timedisc=args.timedisc, cuda_able=args.cuda, cmin=args.cmin, gran=args.gran, count=args.thre)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gamma', type=float, default=0.9, help='discount factor for rewards') parser.add_argument('--alpha', type=float, default=0.1, help='learning rate') parser.add_argument('--epsilon', type=float, default=0.3) parser.add_argument('--num_steps', type=int, default=50, help='number of steps in each episode (default: 50)') parser.add_argument('--max_w', type=int, default=8, help='maze width (default: 8)') parser.add_argument('--max_h', type=int, default=8, help='maze height (default: 8)') parser.add_argument('--nepisodes', type=int, default=1000, help='number of training episodes (default: 1000)') args = parser.parse_args() envirornment = MazeEnvironment(width=args.max_w, height=args.max_h, max_steps=args.num_steps) action_space = envirornment.actions() agent = QLearningAgent(alpha=args.alpha, gamma=args.gamma, epsilon=args.epsilon, action_space=action_space) train(envirornment, agent, args.nepisodes) Util.print_maze(envirornment.masses) Util.q_table_of_each_goal_show(agent.Q_table, action_space, envirornment.width, envirornment.height)
def telemetry(sid, data): if data: # The current steering angle of the car steering_angle = float(data["steering_angle"]) # The current throttle of the car, how hard to push peddle throttle = float(data["throttle"]) # The current speed of the car speed = float(data["speed"]) # The current image from the center camera of the car image = Image.open(BytesIO(base64.b64decode(data["image"]))) try: image = np.asarray(image) # from PIL image to numpy array image = np.array([image]) # the model expects 4D array # predict the steering angle for the image predictions = train(None, image, test=True) steering_angle = float(predictions[len(predictions) - 1]) # lower the throttle as the speed increases # if the speed is above the current speed limit, we are on a downhill. # make sure we slow down first and then go back to the original max speed. global speed_limit if speed > speed_limit: speed_limit = MIN_SPEED # slow down else: speed_limit = MAX_SPEED throttle = 1.0 - steering_angle**2 - (speed / speed_limit)**2 print('{} {} {}'.format(steering_angle, throttle, speed)) send_control(steering_angle, throttle) except Exception as e: print(e) else: sio.emit('manual', data={}, skip_sid=True)
import logging from Train import train from utils import create_logger from GPT2ChatbotConf import GPT2ChatbotConf if __name__ == "__main__": conf = GPT2ChatbotConf() logger = create_logger(conf) train(conf)
def run(): mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) train(mnist)
#load unnormalization values norm_val = pd.read_csv(normfile) pred_price = pred * norm_val['stdev'][0] + norm_val['mean'][0] actual_price = targets * norm_val['stdev'][0] + norm_val['mean'][0] advantage = (pred_price.T / actual_price)[0] #put the deals together and export to file i = 0 adds = np.asarray([]) pred_p = np.asarray([]) act_p = np.asarray([]) for adv in advantage: if adv > 2 and adv < 4: adds = np.append(adds, titles[i]) pred_p = np.append(pred_p, pred_price[i]) act_p = np.append(act_p, actual_price[i]) i += 1 data = pd.DataFrame(adds) data['Predicted'] = pd.DataFrame(pred_p) data['Actual'] = pd.DataFrame(act_p) data.to_csv('deals.csv', sep=',', header=['Title', 'Predicted', 'Actual'], index=False) print('found ', data.shape[0], ' deals. look in deals.csv...') #run the training model to update on new adds train()
def train_NN(CPFile="", datafile="rawdata", dataset=None, SFile="structure", train_ae=False, profiling=False, rho=0.9, LR=0.010, n_epochs=500, batch_size=128, cut=-1, cv_k=10, seed=1000, predict=False, verbose=True): """The core routine for neural net training. Args: CPFile: Checkpoint file from which to resume a training run. Checkpoints are saved automatically as progress is made on a validation set, with standard filename "model_cp" datafile: File from which to retrieve raw data. This is subsequently loaded into a Dataset instance. dataset: Specifies a dataset to load directly. For use with training meta-algorithms that modify the dataset over multiple runs. SFile: The structure file that specifies the neural net architecture. train_ae: Flag for training as an autoencoder. profiling: Flag for turning on profiling for examining performance. rho: Momentum parameter. Standard momentum is used by default for both autoencoder and backprop training. LR: Learning rate. n_epochs: Number of epochs for training. batch_size: SGD mini-batch size. Processing speed increases for larger sizes, but fewer updates are made as a tradeoff. cut: Number of training examples to use from the raw data, with the rest as validation. '-1' indicates look at cv_k. cv_k: 'k' in K-fold validation. 1/k of the data used as a validation set, with the rest as training. seed: specifies random seed. For a given seed, dataset, and neural net architecture, the run will be repeatable. verbose: Flag determining whether to send continual updates to stdout. """ sched_dict = {20: 0.005, 100: 0.001, 200: 0.0001} # This is passed to the theano functions for profiling profmode = NNl.get_profiler(profiling) # A dictionary collecting the necessary training parameters train_params = { 'LR': LR, 'n_epochs': n_epochs, 'rho': rho, 'verb': verbose, 'LRsched': sched_dict } # Create RNGs, one normal one Theano, which are passed to the Builder rng = np.random.RandomState(seed) theano_rng = MRG_RStreams(rng.randint(999999)) rngs = [rng, theano_rng] # Load the dataset, then split for validation if dataset: data = dataset if not data.T: train_params.update( data.prep_validation(batch=batch_size, cut=cut, k=cv_k)) else: train_params.update(data.V_params) else: data = Dataset(datafile, rng) if predict: cv_k = 1 train_params.update( data.prep_validation(batch=batch_size, cut=cut, k=cv_k)) #*** CREATE A MODEL CLASS INSTANCE ***# in_shape = (batch_size, ) + data.sample_dim # Load the checkpoint if there, otherwise use 'structure' to define network if os.path.isfile(CPFile): mymodel = Model(rngs, in_shape, data.label_dim, CPFile, struc_file="") else: mymodel = Model(rngs, in_shape, data.label_dim, struc_file=SFile) if mymodel.zeropad > 0: data.zeropad(mymodel.zeropad) #*** AUTOENCODER ***# #___________________# layers_to_train = [] if train_ae: for layer in mymodel.layers: if layer.tag == "FC": layers_to_train.append(layer) for layer in layers_to_train: if layer.input_layer.tag == "Input": print "@ Autoencoding layer", layer.number, "with RSTanh" activ = NNl.RSTanh else: print "@ Autoencoding layer", layer.number, "with SoftReLU" activ = NNl.SoftReLU functions = create_functions_ae(layer, data.T, activ, batch_size, rho, mymodel.x, mymodel.x_shape[2:], profmode) train_params['logfile'] = NNl.prepare_log(mymodel, data.description) train_params['error'] = layer train(mymodel, functions, train_params) #*** SGD BACKPROP ***# #____________________# if predict: print '@ Predicting' # predict_label(mymodel, data, train_params) cp.dump(class_probs(mymodel, data, train_params), open("class_p", 'wb'), 2) else: print '@ Training with SGD backprop' T_functions = create_functions(mymodel, data, rho, profmode) # Logfile made for analysis of training train_params['logfile'] = NNl.prepare_log(mymodel, data.description) train_params['error'] = mymodel train(mymodel, data, T_functions, train_params) print "\nBest validation: ", mymodel.best_error if profiling: profmode.print_summary() # mymodel.update_model("model_cp") return mymodel
n_episodes = 1000 np.random.seed(0) score_history = {} Loss_history = {} for i in range(n_episodes): obs = env.reset() done = False score = 0 t = 0 score, Loss = train(env, agent, obs, t=0, done=False, score=0) score_j.append(score) score_history[i] = score Loss_history[i] = (np.mean(Loss), 1.96 * np.std(Loss)/np.sqrt(len(Loss))) # (mean, ci) if i % 25 == 0: agent.save_models() print('episode ', i, 'score %.2f' % score, 'trailing 100 games avg %.3f' % np.mean(list(score_history.values())[-100:])) scores_mat[j] = score_j
def customParamsTrain(): loader = DataHandler(epochs=(-0.5, 1), dformat=Formats.tct) patients = [25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38] patients = [str(elem) for elem in patients] date = str(datetime.date.today()) time = datetime.datetime.now().time() time = "{}-{}".format(time.hour, time.minute) experimentFolder = "./Data/Experiments/{}/{}".format(date, time) logger.add(sink=os.path.join(experimentFolder, ".log"), level="INFO") epochs = 50 batchsize = 64 learningRate = 1e-3 temporalLength = 32 dropoutRate = 0.5 D = 2 poolKernel = 16 logger.info( "Model and train parameters: epochs {}, batchsize {}, learningRate {}, temporalLength {}, " "dropoutRate {}, D {}, poolKernel {}".format(epochs, batchsize, learningRate, temporalLength, dropoutRate, D, poolKernel)) dataset = loader.loadHDF( filepath= r"D:\data\Research\BCI_dataset\NewData\All_patients_sr323_ext_win.hdf", keys=patients) trainSet = {} testSet = {} for key, value in dataset.items(): data = value["data"] labels = value["labels"] data = np.expand_dims(data, axis=1) dataset = splitDataset(data, labels, trainPart=0.9, valPart=0.0, permutation=True, seedValue=42069) trainSet[key] = dataset["train"] testSet[key] = dataset["test"] augmenter = getAugmenter() for key, value in trainSet.items(): patientPath = os.path.join(experimentFolder, "{}_patient".format(key)) shape = list(value[0].shape[-2:]) shape[1] = int(config.window[1] * config.sampleRate) - int( config.window[0] * config.sampleRate) model = EEGNet(categoriesN=2, electrodes=shape[0], samples=shape[1], temporalLength=temporalLength, dropoutRate=dropoutRate, D=D, poolPad="same", poolKernel=poolKernel) model.compile(loss="binary_crossentropy", optimizer=tf.optimizers.Adam(learning_rate=learningRate, decay=learningRate / epochs), metrics=["accuracy"]) valAUC = train(model=model, dataset=value, weightsPath=patientPath, epochs=epochs, batchsize=batchsize, crossVal=False, weightedLoss=True, verbose=2, augmenter=augmenter, augProb=0.9, oversample=False, clip=(0.05, 0.35)) testAUC = test(model=model, checkpointPath=os.path.join(patientPath, "best.h5"), dataset=testSet[key], wpath=patientPath, clip=(0.05, 0.35)) logger.info("Patient #{}: val auc {:.2f}, test auc {:.2f}".format( key, valAUC, testAUC))
loggr.info("Wrangling Complete") except Exception as e: loggr.exception("Wrangle.py could not run. Here's why: \n {e}") try: loggr.info( "Training on wrangled data to produce a model for evening predictions". format(datetime.datetime.now().date() + datetime.timedelta(1))) train( target_date=hp["start_date"], label=hp["label"], time_span=hp["time_span"], max_depth=hp["max_depth"], max_features=hp["max_features"], min_samples_leaf=hp["min_samples_leaf"], min_samples_split=hp["min_samples_split"], n_estimators=hp["n_estimators"], cv=hp["cv"], precision=hp["precision"], edge_forecasting=hp["edge_forecasting"], normalize_data=hp["normalize_data"], criterion=hp["criterion"], ) loggr.info("ML Model is now ready") except Exception as e: loggr.exception("Train.py could not run. Here's why: \n {e}") try: loggr.info("Preparing predictions table for tomorrow ({})".format( datetime.datetime.now().date() + datetime.timedelta(1))) wrangle_status = wrangle(
train_len_data_1 = 200 # data_3 len : 307 test_len_data_1 =60 # data_1 len : 64 all_data_len = train_len_data_1 + WS-1 + round_size -1 test_data_len = test_len_data_1 + WS-1 + round_size -1 ### epoch = 2000 model_num =50 train_i ='average'#'add_rare'#'0_5_9_2_4_6'#'made1''one_to_night' tend='0' tend_list = ['0']#['1','2'] qos_level =2.5 #2.5 5 7.5 cell_number =8 add_epoch_to = 1600 #??? for model_i in range(14,model_num): path = './model_' + str(model_i) isExists = os.path.exists(path) if not isExists: print(path,'建立成功') os.makedirs(path) initial(cell_number,n_actions,n_state,learning_rate,model_i,round_size) for batch_size_i in range(1, 2): batch_size = (2 ** batch_size_i) one_hot_state, one_hot_action, X = data_prepro(n_actions, n_state, all_data_len,train_i,'train',round_size) loss, epoch_loss_list = train(cell_number,batch_size,n_actions, n_state, learning_rate, epoch, one_hot_state, X, model_i,qos_level,round_size) plt.plot(np.array(range(epoch)), epoch_loss_list) plt.savefig('./model_' + str(model_i) + '/' + tend + 'loss.png') plt.close()
from Train import train, produce_test_output if __name__ == '__main__': #produce_test_output(model_to_charge='2LayerSigmoidrBatch32.pth') train(file_name='3LayerMixSSRBatch128')
import store from Train import train if __name__ == "__main__": store.vocab.train() train()
loaders = get_dataloaders(Ps, vocab) #------------------------------------------------------------------------- # writer #------------------------------------------------------------------------- writer = make_log(Ps) # onnx failed so we comment out this line #write_tensorboard_models(writer, encoder, decoder, loaders["valid"]) try: acc_best = 90 for epoch in range(1, Ps["num_epochs"]+1): scheduler.step(epoch, [(None,),(None,)]) loss_train, acc_train = train(Ps, loaders["train"], encoder, decoder, criterion, optimizer) loss_valid, acc_valid = validate(Ps, loaders["valid"], encoder, decoder, criterion) get_status(Ps, epoch, loss_train, acc_train, loss_valid, acc_valid) #-- write tensorboard write_tensorboard_scalar(epoch, writer, type="Loss", Train=loss_train, Valid=loss_valid, Valid_Train=loss_valid-loss_train) write_tensorboard_scalar(epoch, writer, type="Accuracy", Train=acc_train, Valid=acc_valid) write_tensorboard_scalar(epoch, writer, type="LearningRate", Encoder=optimizer.param_groups[0]['lr'], Decoder=optimizer.param_groups[1]['lr']) write_tensorboard_scalar(epoch, writer, type="WeightDecay", Encoder=optimizer.param_groups[0]['weight_decay'], Decoder=optimizer.param_groups[1]['weight_decay']) if epoch % Ps["hist_interval"] == 0: write_tensorboard_histogram(epoch, writer, encoder, decoder) #-- checkpoint if Ps["checkpoint"] and acc_valid > acc_best: acc_best = acc_valid
import torch from LetNet import LeNet from Data_process import data_prapare from Train import train from Test import validate if __name__ == "__main__": # 是否使用cuda device = torch.device("cpu") if torch.cuda.is_available(): device = torch.device("cuda") print("Using {} training..".format(device)) # 初始化模型 model = LeNet().to(device) # 加载数据 train_loader, test_loader = data_prapare() # 训练 train(train_loader, model, device) # 验证 validate(test_loader, device)
lstm = PerformanceRNN( input_channels=NUM_CHANNELS + 128 + 5, output_channels=NUM_CHANNELS, hidden_size=1024, num_layers=3, dropout=0.5, ).to('cuda') prime = torch.zeros(1, 1, NUM_CHANNELS + 128 + 5).to('cuda') epochWriter = EpochWriter( model=lstm, name_prefix='performance_rnn_conditioned', get_seq_for_errors=lambda lstm: lstm.forward_step( 1000, prime=prime, condition=get_condition(composers=True)), iteration=5, ) #epochWriter.get_latest_model() train(model=lstm, dataloaders={ phase: MaestroMidiDatasetWithConditioning.get_dataloader(phase, max_data_len=2048, composers=True) for phase in ['train', 'eval'] }, num_epochs=1000, lr=1e-3, epoch_loss_cb=lambda phase, loss, all_losses: epochWriter. write_data_epoch(phase, loss, all_losses))
def main(argv=None): new_train_set, new_train_mask = load_data() print('Loading data finished!') train(new_train_set, new_train_mask)
from Train import train from BERT_BiLSTM_CRF_master.Config import Config if __name__ == "__main__": customer_label_list = ["O", "B-Chemical", "I-Chemical", "B-Dealer", "I-Dealer", "B-Diagnostic", "I-Diagnostic", "B-Hospital", "I-Hospital", "B-Industrial", "I-Industrial", "B-NonProfit", "I-NonProfit", "B-Pharma", "I-Pharma", "B-Service", "I-Service", "B-University", "I-University", "X", "[CLS]", "[SEP]" ] train(customer_label_list = customer_label_list)
def f(x): # return x**2 return np.sin(x)/(((x - np.pi/2)/np.pi)) # return np.sin(x) * np.cos(x) X = [[x] for x in np.arange(0,10,0.01)] Y = [f(x[0]) for x in X] # X,Y = getData("train") p = Population(size=POPULATION,varCount=len(X[0])) train(p, EPOCH_COUNT, X,Y) best = p.getBest() best.eval(X,Y) print("MSE on test : " + str(best.phenotype)) Ypred = [best.computeFunction(x)[0] for x in X] plt.plot([x[0] for x in X], Y, c = 'b',dashes=[6, 3]) plt.plot([x[0] for x in X], Ypred, c = 'r',dashes=[2,6]) plt.show()
def main(): parser = argparse.ArgumentParser() parser.add_argument("-file_name", type=str, default="DCRNN_Provide") parser.add_argument("-beta", type=float, default=2) parser.add_argument("-num_of_graph", type=int, default=1) parser.add_argument("-num_of_neighbors", type=int, default=2) parser.add_argument("-num_of_stations", type=int, default=325) parser.add_argument("-temporal_in_channel", type=int, default=1) parser.add_argument("-spatial_out_channel", type=int, default=4) parser.add_argument("-switch", type=str, default="dot_product") parser.add_argument("-epoch", type=int, default=600) parser.add_argument("-batch_size", type=int, default=48) parser.add_argument("-log", default=None) parser.add_argument("-save_model", default=None) parser.add_argument("-save_mode", type=str, choices=["all", "best"], default="best") option = parser.parse_args() option.save_model = "Result_Models/STGCN" device = torch.device("cpu") training_dataset = DataLoader(Create_Dataset(option.file_name, mode="train", dtype=torch.float, device=device), batch_size=option.batch_size, shuffle=True, num_workers=32) validation_dataset = DataLoader(Create_Dataset(option.file_name, mode="val", dtype=torch.float, device=device), batch_size=option.batch_size, shuffle=True, num_workers=32) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") _, _, c_graph = load_graph_data("DCRNN_Provide/adj_mx_bay.pkl") c_graph = torch.from_numpy(c_graph) s_graph = Graph2S(c_graph, option.beta) # S1 # c_graph = c_graph.unsqueeze(0).repeat(torch.cuda.device_count(), 1, 1).to(device=device, dtype=torch.float) # s_graph = s_graph.unsqueeze(0).repeat(torch.cuda.device_count(), 1, 1).to(device=device, dtype=torch.float) # spatial_graph = c_graph # spatial_graph = [c_graph, s_graph] # S2 graph_0 = torch.eye(option.num_of_stations).unsqueeze(0).to( device=device, dtype=torch.float) graph_1 = c_graph.unsqueeze(0).to(device=device, dtype=torch.float) spatial_graph = torch.cat([graph_0, graph_1 - graph_0], dim=0) model = Prediction_Model(Ks=option.num_of_neighbors, encoder_in_channel=option.temporal_in_channel, encoder_out_channel=option.spatial_out_channel, num_stations=option.num_of_stations, switch=option.switch) # model = LSTM_Model(option.num_of_stations, 1, 4, 1) # model = Merge_ChebNet(2, 96, 6, 1) # model = Merge_GCGRU(option.num_of_stations, 1, [8, 8, 1], 2, 3) model = STGCN_Model(1, 1, [5, 2], option.num_of_stations, False) model = model.to(device) if torch.cuda.device_count() > 1: print("{} GPU(s) will be used.".format(torch.cuda.device_count())) model = nn.DataParallel(model) model_size(model, 0) cudnn.benchmark = True criterion = nn.MSELoss(size_average=False) optimizer = optim.Adam(model.parameters(), lr=1e-3) scheduler = MultiStepLR(optimizer, [10], gamma=1) option.log = option.save_model train(model, training_dataset, validation_dataset, spatial_graph, criterion, optimizer, scheduler, option, device) test_main(option.save_model + ".pkl")
def main(argv=None): mnist = input_data.read_data_sets("Dataset/", one_hot=True) train(mnist)
model = Net(v_feat, a_feat, t_feat, None, train_edge, batch_size, num_user, num_item, 'mean', 'False', 2, True, user_item_dict, weight_decay, dim_E).cuda() ########################################################################################################################################## optimizer = torch.optim.Adam([{ 'params': model.parameters(), 'lr': learning_rate }]) ########################################################################################################################################## max_precision = 0.0 max_recall = 0.0 max_NDCG = 0.0 val_max_recall = 0.0 num_decreases = 0 for epoch in range(num_epoch): loss = train(epoch, len(train_dataset), train_dataloader, model, optimizer, batch_size, writer) if torch.isnan(loss): with open( './Data/' + data_path + '/result_{0}.txt'.format(save_file), 'a') as save_file: save_file.write( 'lr: {0} \t Weight_decay:{1} is Nan\r\n'.format( learning_rate, weight_decay)) break torch.cuda.empty_cache() val_precision, val_recall, val_ndcg = full_vt(epoch, model, val_data, 'Val', writer) test_precision, test_recall, test_ndcg = full_vt( epoch, model, test_data, 'Test', writer)
def main(args): if not os.path.exists(args["modelFolder"]): os.makedirs(args["modelFolder"]) if not os.path.exists(args["summary_dir"]): os.makedirs(args["summary_dir"]) #with tf.device("/gpu:0"): # MADDPG for Ave Agent # DDPG for Good Agent gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.85) with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=True)) as sess: env = make_env.make_env('simple_tag') np.random.seed(int(args['random_seed'])) tf.set_random_seed(int(args['random_seed'])) env.seed(int(args['random_seed'])) #with tf.device('/cpu:0'): #if args["runTest"]: #run() #import sys #sys.exit("test over!") # Calculate good and ave agents number ave_n = 0 good_n = 0 for i in env.agents: if i.adversary: ave_n += 1 else: good_n += 1 print("adversary ", ave_n, "target ", good_n) # print("ave_n", ave_n) n = env.n actors = [] critics = [] brains = [] exploration_noise = [] observation_dim = [] action_dim = [] total_action_dim = 0 # Aversary Agents action spaces for i in range(ave_n): total_action_dim = total_action_dim + env.action_space[i].n print("total_action_dim", total_action_dim) for i in range(n): observation_dim.append(env.observation_space[i].shape[0]) action_dim.append( env.action_space[i].n ) # assuming discrete action space here -> otherwise change to something like env.action_space[i].shape[0] actors.append( ActorNetwork(sess, observation_dim[i], action_dim[i], float(args['actor_lr']), float(args['tau']))) # critics.append(CriticNetwork(sess,n,observation_dim[i],total_action_dim,float(args['critic_lr']),float(args['tau']),float(args['gamma']))) if i < ave_n: #MADDPG - centralized Critic critics.append( CriticNetwork(sess, n, observation_dim[i], total_action_dim, float(args['critic_lr']), float(args['tau']), float(args['gamma']))) else: # DDPG critics.append( CriticNetwork(sess, n, observation_dim[i], action_dim[i], float(args['critic_lr']), float(args['tau']), float(args['gamma']))) exploration_noise.append(OUNoise(mu=np.zeros(action_dim[i]))) """ print("Test predict") s = env.reset() # print(s[0]) actions = [] for index in range(len(actors)): state_input = np.reshape(s[index],(-1,actors[index].state_dim)) actions.append(actors[index].predict(state_input)) actors[index].predict_target(state_input) actions1 = actions[:ave_n] actions2 = actions[ave_n:] a_temp1 = np.transpose(np.asarray(actions1),(1,0,2)) a_for_critic1 = np.asarray([x.flatten() for x in a_temp1]) a_temp2 = np.transpose(np.asarray(actions2),(1,0,2)) a_for_critic2 = np.asarray([x.flatten() for x in a_temp2]) for index in range(len(critics)): state_input = np.reshape(s[index],(-1,actors[index].state_dim)) if index < ave_n: critics[index].predict_target(state_input, a_for_critic1) #critics[index].predict(state_input, a_for_critic1) else: critics[index].predict_target(state_input, a_for_critic2) #critics[index].predict(state_input, a_for_critic2) """ # if args['use_gym_monitor']: # if not args['render_env']: # envMonitor = wrappers.Monitor(env, args['monitor_dir'], video_callable=False, force=True) # else: # envMonitor = wrappers.Monitor(env, args['monitor_dir'], force=True) # n brains if False: for i in range(n): observation_dim.append(env.observation_space[i].shape[0]) action_dim.append(env.action_space[i].n) brains.apppen(Brain(sess, observation_dim[i], action_dim[i], float(args['actor_lr']), float(args['tau']), \ observation_dim[i], total_action_dim, float(args['critic_lr']), float(args['tau']),float(args['gamma']))) exploration_noise.append(OUNoise(mu=np.zeros(action_dim[i]))) # learn() if args["runTest"]: # , force=True # env = wrappers.Monitor(env, args["monitor_dir"], force=True) for i in range(n): # load model actors[i].mainModel.load_weights(args["modelFolder"] + str(i) + '_weights' + '.h5') # episode 4754 import time # time.sleep(3) for ep in range(10): s = env.reset() reward = 0.0 for step in range(200): time.sleep(0.01) env.render() actions = [] for i in range(env.n): state_input = np.reshape( s[i], (-1, env.observation_space[i].shape[0])) noise = OUNoise(mu=np.zeros(5)) # predict_action = actors[i].predict(state_input) #+ exploration_noise[i]() # actions.append(predict_action.reshape(env.action_space[i].n,)) # +noise() actions.append( (actors[i].predict( np.reshape( s[i], (-1, actors[i].mainModel.input_shape[1]))) ).reshape(actors[i].mainModel.output_shape[1], )) #print("{}".format(actions)) s, r, d, s2 = env.step(actions) for i in range(env.n): reward += r[i] if np.all(d): break print("Episode: {:d} | Reward: {:f}".format(ep, reward)) env.close() import sys sys.exit("test over!") if False: import time # , force=True # env = wrappers.Monitor(env, args["monitor_dir"], force=True) for ep in range(10): # load model s = env.reset() for j in range(env.n): actors[j].mainModel.load_weights(args["modelFolder"] + str(j) + '_weights' + '.h5') for step in range(300): reward = 0.0 # time.sleep(0.05) env.render() actions = [] for i in range(env.n): state_input = np.reshape( s[i], (-1, env.observation_space[i].shape[0])) noise = OUNoise(mu=np.zeros(5)) # predict_action = actors[i].predict(state_input) #+ exploration_noise[i]() # actions.append(predict_action.reshape(env.action_space[i].n,)) # +noise() actions.append( (actors[i].predict( np.reshape( s[i], (-1, actors[i].mainModel.input_shape[1]))) ).reshape(actors[i].mainModel.output_shape[1], )) s, r, d, s2 = env.step(actions) for i in range(env.n): reward += r[i] if np.all(d): break print("Episode: {:d} | Reward: {:f}".format(ep, reward)) else: if True: train(sess, env, args, actors, critics, exploration_noise, ave_n) else: global graph, global_queue, update_event, rolling_event, global_step_max, global_step, coord, brain graph = tf.get_default_graph() global_queue = queue.Queue() update_event, rolling_event = threading.Event( ), threading.Event() global_step_max, global_step = 200 * 1000, 0 coord = tf.train.Coordinator() brain = Brain(args["modelFolder"]) distributed_train(sess, env, args, actors, critics, exploration_noise, ave_n)
hidden_channels=64, num_layers=9, num_stacks=4, kernel_size=2, dilation_rate=2, ).to('cuda') print('receptive field:', wavenet.receptive_field) prime = torch.zeros(1, NUM_CHANNELS, wavenet.receptive_field).to('cuda') epochWriter = EpochWriter( model=wavenet, name_prefix='performance_wavenet', get_seq_for_errors=lambda wavenet: wavenet.fast_forward_steps(prime, 1000) iteration=15 ) #epochWriter.get_latest_model() #epochWriter.get_model(6, 12) train_losses, test_losses = train( model=wavenet, dataloaders={ phase: MaestroMidiDataset.get_dataloader(phase, max_data_len=2048) for phase in ['train', 'eval'] }, num_epochs=500, lr=1e-3, epoch_loss_cb=lambda phase, loss, all_losses: epochWriter.write_data_epoch(phase, loss, all_losses) )
Path(dataset["output_dir"]).mkdir(parents=True, exist_ok=True) model_output_file = join(dataset["output_dir"], "model.pt") metric_output_file = join(dataset["output_dir"], "metric.pt") if not exists(model_output_file): with open(model_output_file, "w"): pass if not exists(metric_output_file): with open(metric_output_file, "w"): pass if index > 0: evaluate(model=model, test_loader=test_iterator, title=f'Result Before training on dataset #{index + 1}') train(model=model, optimizer=optimizer, train_loader=train_iterator, test_loader=test_iterator, eval_every=len(train_iterator) // 2, model_output_file=model_output_file, metric_output_file=metric_output_file, num_epochs=10) display_result(model=model, metric_file_location=metric_output_file, test_loader=test_iterator, title=f'Result Dataset #{index + 1} and before') print(f'now finished working on dataset {index + 1}')