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}')
