def test_agents_can_play_games_of_different_dimensions():
config.num_episodes_to_run = 10
config.hyperparameters["DQN_Agents"]["batch_size"] = 3
AGENTS = [A2C, A3C, PPO, DDQN, DQN_With_Fixed_Q_Targets, DDQN_With_Prioritised_Experience_Replay, DQN]
trainer = Trainer(config, AGENTS)
config.environment = gym.make("CartPole-v0")
results = trainer.run_games_for_agents()
for agent in AGENTS:
assert agent.agent_name in results.keys()
AGENTS = [TD3, PPO, DDPG]
config.environment = gym.make("MountainCarContinuous-v0")
trainer = Trainer(config, AGENTS)
results = trainer.run_games_for_agents()
for agent in AGENTS:
assert agent.agent_name in results.keys()
AGENTS = [DDQN, SNN_HRL]
config.environment = Four_Rooms_Environment(15, 15, stochastic_actions_probability=0.25,
random_start_user_place=True, random_goal_place=False)
trainer = Trainer(config, AGENTS)
results = trainer.run_games_for_agents()
for agent in AGENTS:
assert agent.agent_name in results.keys()
def main(datadir,
dataset_start_idx,
dataset_end_idx,
sp=256,
first_layer_ch=24,
discriminator_out_res=32,
model_dir='./results512p'):
root_dir = os.getcwd()
test_dir = os.path.join(root_dir, 'test%dp' % sp)
if os.path.exists(test_dir): shutil.rmtree(test_dir)
os.mkdir(test_dir)
os.mkdir(os.path.join(test_dir, 'gt'))
os.mkdir(os.path.join(test_dir, 'input'))
os.mkdir(os.path.join(test_dir, 'output'))
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
trainer = Trainer(sess, sp, discriminator_out_res)
trainer.test(datadir,
dataset_start_idx,
dataset_end_idx,
24,
first_layer_ch,
results_dir=test_dir,
model_dir=model_dir)
def linear_regression(a=1.0, b=0.0):
X = np.linspace(-100, 100, 200)
X = X.reshape((-1, 1))
[train_x, test_x] = split_data(X, ratio=0.8, random=True)
train_y = a * train_x + b
test_y = a * test_x + b
i = Input(1)
x = Dense(1)(i)
# define trainer
trainer = Trainer(loss='mse',
optimizer=Adam(learning_rate=0.2),
batch_size=50,
epochs=50)
# create model
model = Sequential(i, x, trainer)
model.summary()
# training process
model.fit(train_x, train_y)
# predict
y_hat = model.predict(test_x)
plt.plot(test_x, test_y, 'b')
plt.plot(test_x, y_hat, 'r')
plt.show()
def train_model():
print('Training')
trainer = Trainer()
with keras.backend.get_session().graph.as_default():
e = emb()
trainer.train(e)
return redirect(url_for('admin'))
def problem_1c(n=500):
algorithmList = [
'Perceptron', 'Perceptron with margin', 'Winnow', 'Winnow with margin',
'AdaGrad'
]
bestParaList = {500: [(1, 0), (0.03, 1), (1.1, 0), (1.1, 2.0), (0.25, 1)], \
1000: [(1, 0), (0.03, 1), (1.1, 0), (1.1, 2.0), (0.25, 1)]}
t = Trainer()
d = t.data_generator(l=10,
m=100,
n=n,
number_of_instances=50000,
noise=False)
x, y = d['x'], d['y']
initDict = initDictGenerator(n=t.n)
color = 'rgbyk'
for idx in range(len(algorithmList)):
algorithm = algorithmList[idx]
algorithmInit = initDict[algorithm]
if n in bestParaList:
lr, mg = bestParaList[n][idx]
else:
lr, mg = bestParaList[500][idx]
algorithmInit['learning rate'] = [lr]
algorithmInit['margin'] = [mg]
t.learning(algorithm,
x,
y,
initDict={algorithm: algorithmInit},
times=1)
t._unpack_resDict(lr, mg)
plt.plot(t.mistake_list, color[idx])
plt.legend(algorithmList, loc='best')
plt.title('Plots for n = %s' % n)
plt.show()
def problem_1b(n=500):
# change n for two size of datasets
algorithmList = [
'Perceptron', 'Perceptron with margin', 'Winnow', 'Winnow with margin',
'AdaGrad'
]
t = Trainer()
d = t.data_generator(l=10,
m=100,
n=n,
number_of_instances=50000,
noise=False)
x, y = d['x'], d['y']
D1_x, D1_y, D2_x, D2_y = d['D1_x'], d['D1_y'], d['D2_x'], d['D2_y']
initDict = initDictGenerator(n=t.n)
for algorithm in algorithmList:
algorithmInit = initDict[algorithm]
learningRateList = algorithmInit['learning rate']
marginList = algorithmInit['margin']
t.learning(algorithm, D1_x, D1_y, initDict=initDict, times=20)
for lr in learningRateList:
for mg in marginList:
err_rate = t.error_estimate(t.D2_x, t.D2_y, lr, mg)
mistake = t.mistakeCount(lr, mg)
print(
'LR: {0: >6s}, MG: {1: >6s}, ER: {2: >6s}, Mis: {3: >6s}'.
format(str(lr), str(mg), str(err_rate), str(mistake)))
def problem_3_tuning():
algorithmList = [
'Perceptron', 'Perceptron with margin', 'Winnow', 'Winnow with margin',
'AdaGrad'
]
for m in [100, 500, 1000]:
print()
d = problem_3_dataLoader(m, 'train')
x, y = d['x'], d['y']
D1_x, D1_y, D2_x, D2_y = d['D1_x'], d['D1_y'], d['D2_x'], d['D2_y']
t = Trainer()
t.set_param(l=10, m=m, n=x.shape[1], number_of_instances=x.shape[0])
initDict = initDictGenerator(n=t.n)
for algorithm in algorithmList:
algorithmInit = initDict[algorithm]
learningRateList = algorithmInit['learning rate']
marginList = algorithmInit['margin']
t.learning(algorithm, D1_x, D1_y, initDict=initDict, times=20)
for lr in learningRateList:
for mg in marginList:
err_rate = t.error_estimate(D2_x, D2_y, lr, mg)
mistake = t.mistakeCount(lr, mg)
print(
'LR: {0: >6s}, MG: {1: >6s}, ER: {2: >6s}, Mis: {3: >6s}'
.format(str(lr), str(mg), str(err_rate), str(mistake)))
def main(datadir, dataset_start_idx, dataset_end_idx, data_use_num,
sp=256, first_layer_ch=24,
batch_size=8, epoch_num=40,
discriminator_out_res=32,
mode='retrain', pre_model_dir=None):
root_dir = os.getcwd()
graph_dir = os.path.join(root_dir, 'graph%dp' % sp)
results_dir = os.path.join(root_dir, 'results%dp' % sp)
code_bk_dir = os.path.join(results_dir, 'code_bk')
if mode == 'retrain' or mode == 'finetune':
import shutil
if os.path.exists(graph_dir): shutil.rmtree(graph_dir)
if os.path.exists(results_dir): shutil.rmtree(results_dir)
os.mkdir(results_dir)
os.mkdir(code_bk_dir)
# backup source code
file_list = os.listdir(root_dir)
for item in file_list:
full_name = os.path.join(root_dir, item)
if os.path.isfile(full_name) and item.endswith('.py'):
shutil.copy(full_name, os.path.join(code_bk_dir, item))
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
logger.set_log_file(os.path.join(results_dir, 'log.txt'))
logger.write('Constructing network graph...')
trainer = Trainer(sess, sp, discriminator_out_res)
trainer.train(datadir, dataset_start_idx, dataset_end_idx, data_use_num, 24, first_layer_ch,
results_dir=results_dir, graph_dir=graph_dir,
batch_size=batch_size, epoch_num=epoch_num,
mode=mode, pre_model_dir=pre_model_dir)
def run(self, Train=True, Test=False):
print("Running on", self.arg.device)
self.set_device(self.arg.device)
np.random.seed(self.arg.seed)
torch.manual_seed(self.arg.seed)
# create training set
if self.arg.data_path:
log('loading corpus from %s' % self.arg.data_path)
if not os.path.exists(self.arg.output_path):
os.makedirs(self.arg.output_path)
os.makedirs(self.arg.output_path + "/code")
os.makedirs(self.arg.output_path + "/code/models")
self.define_input_field() # define the fields of several inputs
print(self.arg)
print(self.bertConfig)
print(self.bertTokenizer)
consts.TOKEN_MASK_TYPE = self.arg.token_mask_type
self.train_set = self.construct_dataset(self.train, keep_events=1, skip_sample=self.arg.skip_sample, tokenizer=self.bertTokenizer) # load datafiles and transinto field
self.dev_set = self.construct_dataset(self.dev, tokenizer=self.bertTokenizer)
self.test_set = self.construct_dataset(self.test, tokenizer=self.bertTokenizer)
self.buil_field_vocab() # build vocab on train and dev set
tester = self.get_tester()
if self.arg.restart > 0:
log('init model from ' + self.arg.demo_model)
self.model = self.load_model(self.arg.demo_model)
log('model loaded, there are %i sets of params' % len(self.model.parameters_requires_grad_clipping()))
else:
self.model = self.load_model(None)
log('model created from scratch, there are %i sets of params' % len(self.model.parameters_requires_grad_clipping()))
self.arg.word_i2s = self.WordsField.vocab.itos
self.arg.trigger_label_i2s = self.TriggerLabelField.vocab.itos
optimizer_constructor, bert_optimizer_constructor = self.get_otimizer_constructor(self.model)
trainer = Trainer(model=self.model, args=self.arg, word_i2s=self.arg.word_i2s, EERuner=self,
optimizer_constructor=optimizer_constructor,
bert_optimizer_constructor=bert_optimizer_constructor, tester=tester)
if Train:
print("backup codes")
os.system("cp config.cfg {}".format(self.arg.output_path))
os.system("cp network/models/*.py {}".format(self.arg.output_path + "/code/models"))
self.store_vec()
train_writer = SummaryWriter(os.path.join(self.arg.output_path, "train"))
detection_writer = SummaryWriter(os.path.join(self.arg.output_path, "detection"))
classification_writer = SummaryWriter(os.path.join(self.arg.output_path, "classification"))
self.arg.writer = {"train": train_writer, "detect": detection_writer, "cls": classification_writer}
trainer.train(train_set=self.train_set, dev_set=self.dev_set, test_set=self.test_set, epochs=
self.arg.epochs, other_testsets={})
self.arg.writer["train"].close()
self.arg.writer["detect"].close()
self.arg.writer["cls"].close()
if Test:
trainer.eval(test_set=self.test_set)
log('Done!')
def main():
print "Select Network Type"
print "1. MLP"
print "2. Radial Basis"
nn_type = raw_input()
nn = NeuralNetwork()
if nn_type == "1":
num_inputs = int(raw_input("Enter number inputs"))
num_hidden = int(raw_input("Enter number hidden layers"))
nn = MLPNN(num_inputs, num_hidden)
elif nn_type == "2":
num_inputs = int(raw_input("Enter number inputs"))
num_centers = int(raw_input("Enter number radial basis functions"))
nn = RBNN(num_inputs, num_centers)
trainer = Trainer(nn)
tester = Tester(nn)
if nn_type == "1":
trainer.trainMLP(str(num_inputs))
tester.test(str(num_inputs))
elif nn_type == "2":
trainer.trainRB(str(num_inputs))
tester.testRB(str(num_inputs))
def main():
with open('./misc/SPAIR.json') as f:
config = json.load(f)
X, bg = load_SDNET2018(True)
N, H, W, _ = X.shape
bg = bg.reshape(N, 1, 1, 3).repeat(1, H, W, 1)
X, test = torch.split(X, [N - 1, 1])
bg, testBg = torch.split(bg, [N - 1, 1])
with Trainer(**config) as trainer:
if trainer.start_epoch > 0:
with torch.no_grad():
trainer.spair.eval()
trainer.summary.add_graph(
trainer.spair,
(test.permute(0, 3, 1, 2).to(trainer.device),
testBg.permute(0, 3, 1, 2).to(trainer.device)))
trainer.summary.add_images('reconstruct/origin',
test,
0,
dataformats='NHWC')
for i in trainer.train(X, bg):
rec = trainer.reconstruct(test, testBg) # [N, C, H, W]
trainer.summary.add_images('reconstruct/reconstruct', rec, i)
def main(config, args):
config["result_dir"] = args.path
print(config["result_dir"])
torch.manual_seed(config["seed"])
random.seed(config["seed"])
np.random.seed(config["seed"])
path_data = config['path'] + "/safe_set_data.pth"
if config['load_data']:
data_loader = torch.load(path_data)
data_loader.setBatchSize(config['n_batch'], config['train_val_ratio'])
else:
data_loader = DataLoader.DataLoader(config)
torch.save(data_loader, path_data)
print(data_loader.n_all_batches)
model = SafeSet.SafeSet(config)
path_model = config['path'] + "/safe_set_model.pth"
path_model_results = config["result_dir"] + "/safe_set_model.pth"
if not config['load_model']:
trainer = Trainer.Trainer(config)
trainer.train(model, data_loader)
torch.save(model, path_model)
torch.save(model, path_model_results)
else:
model = torch.load(path_model)
validation = Validation.Validation(config)
validation.validate(model, data_loader)
validation.validateTest(model, data_loader)
validation.validateTestUnseen(model, data_loader)
validation.save_val()
validation.save_model(model)
def cross_valid_objective(self, trial):
losses = []
for train, valid in self.splitter():
train_sampler = StratifiedSampler(torch.tensor(train.gettargets()),
batch_size=self.tbSz)
valid_sampler = StratifiedSampler(torch.tensor(valid.gettargets()),
batch_size=self.vbSz)
train_loader = DataLoader(train,
sampler=train_sampler,
batch_size=self.tbSz,
num_workers=self.nWo)
valid_loader = DataLoader(valid,
sampler=valid_sampler,
batch_size=self.vbSz,
num_workers=self.nWo)
trainer = Trainer(self.model,
self.device,
self.objectiveloss,
trainloader=train_loader,
validloader=valid_loader,
hyperparams=self.hyperparams,
tbwriter=self.writer)
loss_v = trainer(trial=trial)
losses.append(loss_v)
return np.mean(losses)
def create_user():
"""Prompts a new user to setup their account. Once all their information is established, they are added to the database"""
print("create user function")
username = input('Please Enter a Trainer Name ')
db.execute('SELECT username FROM trainer WHERE username= :user',
{'user': username})
test_name = db.fetchone()
if not test_name:
db.execute('INSERT INTO trainer (username) VALUES (:user)',
{'user': username})
conn.commit()
db.execute('SELECT * FROM trainer WHERE username= :username',
{'username': username})
name = db.fetchone()
create_party(name[0])
pokemon_party = trainer_party(name[0])
user = Trainer(name[1], name[0], pokemon_party)
main_menu(user)
else:
print('---- SORRY USERNAME TAKEN ----')
create_user()
def __init__(self,
DATA_DIR,
ALPHA_DIR,
MODEL,
BATCH_SIZE,
HIDDEN_DIM,
SEQ_LENGTH,
LAYER_NUM,
DBG=False):
set_debug(DBG)
debug('[TextRNN]: Loading data...')
X, y, VOCAB_SIZE, ix_to_char, chars = load_data(
DATA_DIR, ALPHA_DIR, SEQ_LENGTH)
debug('[TextRNN]: Creating ModelHandler...')
self.modelhandler = ModelHandler(HIDDEN_DIM, VOCAB_SIZE, LAYER_NUM,
MODEL)
debug('[TextRNN]: Loading model...')
self.model = self.modelhandler.load()
debug('[TextRNN]: Creating Trainer...')
self.trainer = Trainer(MODEL, self.model, X, y, VOCAB_SIZE, ix_to_char,
chars, BATCH_SIZE)
def train_model(songs_data):
"""Input: list of data on several songs (could be a single song)
Ouput: a model trained on all of the songs"""
bars = get_bars(songs_data)
trainer = Trainer(bars)
m, alphabet = trainer.train()
return (m, alphabet)
def test():
from Trainer import Trainer
from dataset.mnist import load_mnist
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False);
max_epochs = 1;
network = SimpleConvNet(input_dim=(1, 28, 28),
conv_params={'filter_num': 30, 'filter_size': 5, 'padding': 0, 'stride': 1},
hidden_size=100, output_size=10, weight_init_std=0.01);
trainer = Trainer(network, x_train, t_train, x_test, t_test, epochs=max_epochs,
mini_batch_size=100, optimizer='Adam', optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000);
# network.showNetwork();
print("======================================================================")
print("Max Iteration : {}".format(trainer.max_iter));
print("======================================================================")
trainer.train();
# Save the trained parameters
print("save .........................")
network.save_params("ttt.pkl");
print("Saved network parameters!!!");
def __call__(self):
self.study.optimize(self.cross_valid_objective, n_trials=self.nTr)
if self.hyperparams is None:
self.hyperparams = {}
for key in self.study.best_params:
self.hyperparams[key] = self.study.best_params[key]
train_sampler = StratifiedSampler(torch.tensor(
self.splitter.dataset.gettargets()),
batch_size=self.tbSz)
train_loader = DataLoader(self.splitter.dataset,
sampler=train_sampler,
batch_size=self.tbSz,
num_workers=self.nWo)
final_trainer = Trainer(self.model,
self.device,
self.objectiveloss,
trainloader=train_loader,
validloader=None,
hyperparams=self.hyperparams,
tbwriter=self.writer)
self.final_loss = final_trainer()
def equation_report_early_switching(eq, func_dict, weight_dict, constraints_dict, size_dict, nruns=10):
func_set = func_dict[eq]
tweight = weight_dict[eq]
constraints_func = constraints_dict[eq]
nsamples = size_dict[eq]
trainer = Trainer(path="data//", save=True, load=True, master_file="OtherEquations.csv")
dl = DEAPLearningSystem(func_list=func_set, ngens=15, algorithm="earlyswitcher", population_size=50)
weightlist = [tweight for i in range(nruns)]
no_examples = 1
for i in range(no_examples):
data =[]
for weight in weightlist:
dl.set_add_func(lambda dls, x, y : constraints_func(dls, x, y, weight=weight))
#dl.set_lgml_func(lgml_func)
df = trainer.predict_equations(dl, no_train_samples=nsamples, eqs=[eq], use_gens=True)
temp = df.loc[0, :]
temp["Weight"] = weight
temp["MSE"] = temp["Error"][0]
temp["Truth Error"] = temp["Error"][1]
temp = temp.reindex(index=['Weight', 'Predicted Equation', 'MSE',"Truth Error", 'Time Taken'])
data.append(temp)
final_df = pd.DataFrame(data)
final_df.set_index("Weight")
final_df.to_csv(f"{eq}EarlySwitching{i}.csv", index=False)
def __init__(self, session=None, arguments=None): self.sess = session self.args = arguments # Initialize Gym environment. self.environment = gym.make(self.args.env) if self.args.env=='MountainCarContinuous-v0': input_dimensions = 2 output_dimensions = 1 elif self.args.env=='InvertedPendulum-v2': input_dimensions = 4 output_dimensions = 1 elif self.args.env=='FetchReach-v0': input_dimensions = 16 output_dimensions = 4 elif self.args.env=='FetchPush-v0': input_dimensions = 31 output_dimensions = 4 # Initialize a polivy network. self.ACModel = ActorCriticModel(input_dimensions,output_dimensions,number_layers=4,hidden_units=40,sess=session,to_train=self.args.train, env=self.args.env) # Create the actual network if self.args.weights: self.ACModel.create_policy_network(session, pretrained_weights=self.args.weights,to_train=self.args.train) else: self.ACModel.create_policy_network(session, to_train=self.args.train) # Initialize a memory replay. self.memory = ReplayMemory() # Create a trainer instance. self.trainer = Trainer(sess=session,policy=self.ACModel, environment=self.environment, memory=self.memory,args=self.args)
def main(args):
print("Loading Training Data:", args.training)
print("args.featureName:", args.features)
print("args.PCA:", args.PCA)
print("args.features:", args.features)
print("args.imbalance:", args.imbalance)
print("args.network:", args.network)
print("args.LR:", args.LR)
print("args.VLAD_k:", args.VLAD_k)
print("args.max_epoch:", args.max_epoch)
print("flush!", flush=True)
from Dataset import dataset
my_dataset = dataset()
my_dataset.loadTrainingDataset(
path_data=args.training,
featureName=args.features,
PCA=args.PCA,
imbalance=args.imbalance,
batch_size=args.batch_size,
window_size_sec=args.WindowSize,
)
my_dataset.loadValidationDataset(
path_data=args.validation,
featureName=args.features,
PCA=args.PCA,
window_size_sec=args.WindowSize,
)
my_dataset.loadTestingDataset(
path_data=args.testing,
featureName=args.features,
PCA=args.PCA,
window_size_sec=args.WindowSize,
)
# define Network
from Network import networkMinutes
my_network = networkMinutes(my_dataset, args.network, VLAD_k=args.VLAD_k)
# define Trainer
from Trainer import Trainer
my_trainer = Trainer(my_network, my_dataset)
vals_train, vals_valid, vals_test, model = my_trainer.train(
epochs=args.max_epoch, learning_rate=args.LR, tflog=args.tflog)
#vals_train, vals_valid, vals_test, model = 0,0,0,"pippo"
if (".csv" in args.csv_file and args.jobid >= 0
and ("BUTTA" not in args.tflog.upper())):
print("saving results to csv file")
df = pd.read_csv(args.csv_file, index_col=0)
df.set_value(args.jobid, "train_mAP", vals_train["mAP"])
df.set_value(args.jobid, "train_Acc", vals_train["accuracy"])
df.set_value(args.jobid, "valid_mAP", vals_valid["mAP"])
df.set_value(args.jobid, "valid_Acc", vals_valid["accuracy"])
df.set_value(args.jobid, "test_mAP", vals_test["mAP"])
df.set_value(args.jobid, "test_Acc", vals_test["accuracy"])
print(model)
df.set_value(args.jobid, "model", model)
df.to_csv(args.csv_file, sep=',', encoding='utf-8')
def test_agent_solve_bit_flipping_game():
AGENTS = [PPO, DDQN, DQN_With_Fixed_Q_Targets, DDQN_With_Prioritised_Experience_Replay, DQN, DQN_HER]
trainer = Trainer(config, AGENTS)
results = trainer.run_games_for_agents()
for agent in AGENTS:
agent_results = results[agent.agent_name]
agent_results = np.max(agent_results[0][1][50:])
assert agent_results >= 0.0, "Failed for {} -- score {}".format(agent.agent_name, agent_results)
def problem_2_plot():
algorithmList = [
'Perceptron', 'Perceptron with margin', 'Winnow', 'Winnow with margin',
'AdaGrad'
]
bestParaList = {
40: [(1, 0), (0.25, 1), (1.1, 0), (1.1, 2.0), (1.5, 1)],
80: [(1, 0), (0.03, 1), (1.1, 0), (1.1, 2.0), (0.25, 1)],
120: [(1, 0), (0.03, 1), (1.1, 0), (1.1, 2.0), (0.25, 1)],
160: [(1, 0), (0.03, 1), (1.1, 0), (1.1, 2.0), (0.25, 1)],
200: [(1, 0), (0.25, 1), (1.1, 0), (1.1, 2.0), (1.5, 1)]
}
record = {}
for algorithm in algorithmList:
record[algorithm] = []
for n in range(40, 240, 40):
print()
t = Trainer()
d = t.data_generator(l=10,
m=20,
n=n,
number_of_instances=50000,
noise=False)
x, y = d['x'], d['y']
initDict = initDictGenerator(n=t.n)
color = 'rgbyk'
for idx in range(len(algorithmList)):
algorithm = algorithmList[idx]
algorithmInit = initDict[algorithm]
if n in bestParaList:
lr, mg = bestParaList[n][idx]
else:
lr, mg = bestParaList[500][idx]
algorithmInit['learning rate'] = [lr]
algorithmInit['margin'] = [mg]
t.learningWithStop(algorithm,
x,
y,
initDict={algorithm: algorithmInit},
times=1)
print(len(t.resDict[lr, mg][3]))
t._unpack_resDict(lr, mg)
record[algorithm].append(t.mistake_list[-1])
i = 0
for algorithm in algorithmList:
plt.plot(range(40, 240, 40), record[algorithm], color[i])
i += 1
plt.legend(algorithmList, loc='best')
plt.xlabel('Number of total features')
plt.xticks(range(40, 240, 40))
plt.ylabel('Total Mistakes before stop')
#plt.title('Plots for n = %s'%n)
plt.savefig('p2plot.png', dpi=144)
plt.show()
def create_from_params(params):
"""
:type params: TrainParameters
"""
text_predictor = TextPredictor.load(params.model_file_name)
trainer = Trainer(params.model_file_name,
sequence_processor=text_predictor.sequence_processor,
sequence_model=text_predictor.sequence_model)
return Socrates(trainer=trainer, text_predictor=text_predictor)
def __init__(self, hidden_size, model_path, interface="Ethernet"):
self.interface = interface
self.action_num = 2
self.trainer = Trainer(hidden_size, Behavior.TEACH, Mode.HYBRID)
self.detector = DetectionSystem(hidden_size, interface)
self.trainer.load_model(model_path)
self.detector.load_model(model_path)
def start_squats(source=None, vid=None):
from Squats import Squats
from Trainer import Trainer
print(source, vid)
cpu = True if processor == "cpu" else False
frame_provider = get_frameProvider(source, vid)
squats = Squats()
trainer = Trainer(frame_provider, squats, net)
trainer.start_training(cpu)
def run(self, train_batches, test_batches):
# training and validation error collector
ec = ErrorCollector()
print("-----ModelTester-----")
logging.info("-----ModelTester-----")
for n_hidden in self.n_hidden:
for n_layer in self.n_layer:
if self.is_res_net:
self.models.append(
ResNetModel(n_in=self.n_in,
n_hidden=n_hidden,
n_out=self.n_out,
n_layer=n_layer,
activation='relu'))
else:
for activation in self.activation:
# create models
self.models.append(
Model(n_in=self.n_in,
n_hidden=n_hidden,
n_out=self.n_out,
n_layer=n_layer,
activation=activation))
for model in self.models:
trainer = Trainer(model, train_batches, ec)
for learning_rate in self.learning_rates:
trainer.train(learning_rate, self.epochs, early_stop_lim=25)
# print error plots
ec.plotTrainTestError(model, train_batches.batch_size,
learning_rate, self.epochs,
model.activation)
ec.plotTrainTestAcc(model, train_batches.batch_size,
learning_rate, self.epochs,
model.activation)
ec.resetErrors()
evaluator = Evaluator(model, test_batches,
trainer.getSaveFilePath())
test_loss, test_acc = evaluator.eval()
trainer.resetBestScore()
if self.best_test_acc == 0 or test_acc > self.best_test_acc:
self.best_test_acc = test_acc
self.best_model_param = 'Param_' + model.name + '_ep-' + str(
self.epochs) + '_hidu-' + str(
model.n_hidden) + '_hidl-' + str(
model.n_layer) + '_lr-' + str(learning_rate)
print(
"-----ModelTester finished, best test acc: [%.6f] with model: %s "
% (self.best_test_acc, self.best_model_param))
logging.info(
"-----ModelTester finished, best test acc: [%.6f] with model: %s "
% (self.best_test_acc, self.best_model_param))
def __init__(self, config, vgg, negative_actor, negative_critic, positive_actor, positive_critic, img_path_seqs, name_seqs):
self.current_path = []
self.name_seqs = name_seqs
self.img_path_seqs = img_path_seqs
self.vgg = vgg
self.negative_actor = negative_actor
self.negative_critic = negative_critic
self.positive_actor = positive_actor
self.positive_critic = positive_critic
self.config = config
self.dataset = config.unicode("dataset").lower()
self.load_init = config.unicode("load_init", "") # the second augument is the default value
self.load = config.unicode("load", "")
self.task = config.unicode("task", "train")
self.use_partialflow = config.bool("use_partialflow", False)
self.do_oneshot_or_online_or_offline = self.task in ("oneshot_forward", "oneshot", "online", "offline")
if self.do_oneshot_or_online_or_offline:
assert config.int("batch_size_eval", 1) == 1
self.need_train = self.task == "train" or self.do_oneshot_or_online_or_offline or self.task == "forward_train"
self.session = tf.InteractiveSession(config=tf.ConfigProto(allow_soft_placement=True))
self.coordinator = tf.train.Coordinator()
self.valid_data = load_dataset(config, "valid", self.session, self.coordinator)
if self.need_train:
self.train_data = load_dataset(config, "train", self.session, self.coordinator)
self.num_epochs = config.int("num_epochs", 1000)
self.model = config.unicode("model")
self.model_base_dir = config.dir("model_dir", "models")
self.model_dir = self.model_base_dir + self.model + "/"
self.save = config.bool("save", True)
self.global_step = tf.Variable(0, name='global_step', trainable=False)
self.start_epoch = 0
reuse_variables = None
if self.need_train:
freeze_batchnorm = config.bool("freeze_batchnorm", False)
self.train_network = Network(config, self.train_data, self.global_step, training=True,
use_partialflow=self.use_partialflow,
do_oneshot=self.do_oneshot_or_online_or_offline,
freeze_batchnorm=freeze_batchnorm, name="trainnet")
reuse_variables = True
else:
self.train_network = None
with tf.variable_scope(tf.get_variable_scope(), reuse=reuse_variables):
self.test_network = Network(config, self.valid_data, self.global_step, training=False,
do_oneshot=self.do_oneshot_or_online_or_offline, use_partialflow=False,
freeze_batchnorm=True, name="testnet")
print >> log.v1, "number of parameters:", "{:,}".format(self.test_network.n_params)
self.trainer = Trainer(config, self.train_network, self.test_network, self.global_step, self.session)
self.saver = tf.train.Saver(max_to_keep=0, pad_step_number=True)
tf.global_variables_initializer().run()
tf.local_variables_initializer().run()
tf.train.start_queue_runners(self.session)
self.load_init_saver = self._create_load_init_saver()
if not self.do_oneshot_or_online_or_offline:
self.try_load_weights()
def start_pushup(source=None, vid=None):
print(source, vid)
frame_provider = get_frameProvider(source, vid)
cpu = True if processor == "cpu" else False
from Trainer import Trainer
from Pushup import Pushup
pushup = Pushup()
trainer = Trainer(frame_provider, pushup, net)
trainer.start_training(cpu)
def test_get_mean_and_standard_deviation_difference_results():
"""Tests that get_mean_and_standard_deviation_difference_results method produces correct output"""
results = [[1.0, 2.0, 3.0], [5.0, -33.0, 55.0], [2.5, 2.5, 2.5]]
mean_results = [
np.mean([1.0, 5.0, 2.5]),
np.mean([2.0, -33.0, 2.5]),
np.mean([3.0, 55.0, 2.5])
]
std_results = [
np.std([1.0, 5.0, 2.5]),
np.std([2.0, -33.0, 2.5]),
np.std([3.0, 55.0, 2.5])
]
mean_minus_1_std = [
mean - std_val for mean, std_val in zip(mean_results, std_results)
]
mean_plus_1_std = [
mean + std_val for mean, std_val in zip(mean_results, std_results)
]
config = Config()
config.standard_deviation_results = 1.0
trainer = Trainer(config, [])
mean_minus_x_std_guess, mean_results_guess, mean_plus_x_std_guess = trainer.get_mean_and_standard_deviation_difference_results(
results)
assert mean_results == mean_results_guess
assert mean_minus_1_std == mean_minus_x_std_guess
assert mean_plus_1_std == mean_plus_x_std_guess
config.standard_deviation_results = 3.0
trainer = Trainer(config, [])
mean_minus_x_std_guess, mean_results_guess, mean_plus_x_std_guess = trainer.get_mean_and_standard_deviation_difference_results(
results)
mean_plus_3_std = [
mean + 3.0 * std_val
for mean, std_val in zip(mean_results, std_results)
]
mean_minus_3_std = [
mean - 3.0 * std_val
for mean, std_val in zip(mean_results, std_results)
]
assert mean_results == mean_results_guess
assert mean_minus_3_std == mean_minus_x_std_guess
assert mean_plus_3_std == mean_plus_x_std_guess
