def __train(lr, weight_decay, epocs=50): network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10, weight_decay_lambda=weight_decay) trainer = Trainer(network, x_train, t_train, x_val, t_val, epochs=epocs, mini_batch_size=100, optimizer='sgd', optimizer_param={'lr': lr}, verbose=False) trainer.train() return trainer.test_acc_list, trainer.train_acc_list
def __init__(self): self.onl = Online() self.vis = Metric_Visualizer() self.trainer = Trainer(sess_type="online") self.serv = ExperienceServer(self.ob_callback, deserialize_obs(), 4) self.exp_path = self.trainer.get_exp_path() self.modelpath = self.trainer.get_model_path() self.modelname = self.trainer.get_model_name() m.patch()
def setUp(self): self.trainer = Trainer(None, None) self.dataset = DatasetwithCombinedInput(SimpleDataset(num = 2, size = self.dataset_size)) params = TrainerParams() params.batch_size = 10 params.val_check_period = 0 params.max_epochs = 1 self.params = params tf.reset_default_graph()
class SSIL_server(object): """ Serverside Class for Self Supervised Imitation Learning (runs on the server) """ def __init__(self): self.onl = Online() self.vis = Metric_Visualizer() self.trainer = Trainer(sess_type="online") self.serv = ExperienceServer(self.ob_callback, deserialize_obs(), 4) self.exp_path = self.trainer.get_exp_path() self.modelpath = self.trainer.get_model_path() self.modelname = self.trainer.get_model_name() m.patch() def ob_callback(self, obs_array): obs_array = transform_obsarray(obs_array, flipNonZero()) pkl_name = self.onl.save_obsarray_to_pickle( obs_array, os.path.join(self.exp_path, 'data')) self.vis.vid_from_pklpath(os.path.join(self.exp_path, 'data', pkl_name), 0, 0, show_steer=True, units='rad', live=True) self.trainer.train_model([pkl_name]) #Send model back with open(os.path.join(self.modelpath, "train_" + self.modelname), 'rb') as binary_file: model_dump = bytes(binary_file.read()) return [model_dump] def start_serv(self): self.serv.start() self.serv.join()
from nnet.Metric_Visualizer import Metric_Visualizer from common.Trainer import Trainer import os, pdb, glob vis = Metric_Visualizer() trainer = Trainer() exp_path = trainer.get_exp_path() listy = os.listdir(os.path.join(exp_path, 'data')) for i in range(len(listy)): pkl_name = 'batch' + str(i) vis.vid_from_pklpath(os.path.join(exp_path, 'data', pkl_name), 0, 0, show_steer=True, units='rad', live=True, wk=0)
element_dict = { 'encoder': ConvEncoder(config.convs, DenseElement), #CapsEncoder(),#ConvEncoder(), 'predictor': EmptyElementConfig( ), #DensePredict(),#CapsPredict(),#EmptyElementConfig(), } super().__init__(modes_dict, 'classification', element_dict, config=config) dataset = SimpleDataset(num=2) save_folder = 'simple-test' params = TrainerParams(0.001) params.batch_size = 1 params.val_check_period = 0 params.max_epochs = 100 network_base = SimpleTestNetwork() network = Network(network_base, *network_base.get_functions_for_trainer()) tf.reset_default_graph() trainer = Trainer(network, dataset, params) saver = CustomSaver(folders=[ save_folder + '/classification', save_folder + '/classification/epoch' ]) trainer.train(saver, restore_from_epochend=True)
# coding: utf-8 import sys sys.path.append('../../') import numpy as np import matplotlib.pyplot as plt from data.mnist import load_mnist from DeepCNN import DeepCNN from common.Trainer import Trainer (x_train, t_train), (x_test, t_test) = load_mnist(flatten=False) network = DeepCNN() trainer = Trainer(network, x_train, t_train, x_test, t_test, epochs=20, mini_batch_size=100, optimizer='Adam', optimizer_param={'lr': 0.001}, evaluate_sample_num_per_epoch=1000) trainer.train() # パラメータの保存 network.save_params("deep_convnet_params.pkl") print("Saved Network Parameters!")
class TestLPElements(unittest.TestCase): dataset_size = 20 def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.print_train_output = False self.trainer = None def no_output(self, f): #sys.stdout = open(os.devnull, 'w') # hide messages with contextlib.redirect_stdout(None): f() #sys.stdout = sys.__stdout__ # restore output def control_output(self, f): if not self.print_train_output: self.no_output(f) else: f() def run_trainer(self, config = LpTestNetworkConfig()): network_base = LpTestNetwork(config = config) network = Network(network_base, *network_base.get_functions_for_trainer()) self.trainer.resetTrainerWith(network, self.dataset, self.params) saver = NoSaveSaver(allow_empty = True) self.trainer.train(saver, restore_from_epochend = True) return def get_config_with_mocked_element(self, f = None): config = LpTestNetworkConfig() element = LinearProgrammingDenseElement(config.num_outputs) def step_mock(X, y, training): return y element.step = Mock(side_effect = step_mock if f is None else f) config.convs.convs = [element] return config ### TEST INITIALIZATION ### def setUp(self): self.trainer = Trainer(None, None) self.dataset = DatasetwithCombinedInput(SimpleDataset(num = 2, size = self.dataset_size)) params = TrainerParams() params.batch_size = 10 params.val_check_period = 0 params.max_epochs = 1 self.params = params tf.reset_default_graph() ### TEST CASES ### def test_step_called(self): config = self.get_config_with_mocked_element() self.control_output(lambda: self.run_trainer(config)) self.assertGreaterEqual(config.convs.convs[0].step.call_count, 1, 'Step function should be called at least once') def test_step_executed_for_every_example(self): self.num_ex = tf.Variable(0, dtype = tf.int16, trainable = False) self.result = -1 def step_mock_acc(X, y, training): num_ex_update = tf.assign(self.num_ex, self.num_ex + 1) with tf.control_dependencies([num_ex_update]): y = tf.identity(y) # using just return does not add update step to graph return y def save_num_ex(): self.result = self.num_ex.eval() config = self.get_config_with_mocked_element(step_mock_acc) self.trainer.set_on_train_complete(save_num_ex) self.control_output(lambda: self.run_trainer(config)) self.assertEqual(self.result, self.dataset_size * 2, 'Update should be executed for each training and testing example in dataset') def test_perfect_result(self): # to prove output of step can be compared to y self.test_acc = -1.0 def save_acc(test_loss, test_acc): # test loss is pretty big, because y doesn't contain logits rather than actual probabilities self.test_acc = test_acc self.trainer.set_on_test_complete(save_acc) config = self.get_config_with_mocked_element() self.control_output(lambda: self.run_trainer(config)) np.testing.assert_allclose(self.test_acc, [1.0], rtol = 0.0, atol = 1e-6, err_msg = 'Accuracy should be 1.0 as long as element returns y as its output') def test_creates_out_layer(self): config = LpTestNetworkConfig() self.control_output(lambda: self.run_trainer(config)) layers = config.convs.convs[0].layers _, y = self.dataset.get_batch(self.dataset.get_dataset('train'), 0, 1) self.assertGreaterEqual(len(layers), 1, 'Should have at least one layer') self.assertEqual(len(layers[-1]), y.shape[-1], 'Number of elements in last layer should be equal to number of classes') def test_initializes_only_once(self): config = LpTestNetworkConfig() X, y = self.dataset.get_batch(self.dataset.get_dataset('train'), 0, 1) element = config.convs.convs[0] X = np.reshape(X[0], [-1, np.multiply.reduce(X[0].shape[1:])]) element.init_out_layer(X.shape, y.shape) element.layers[-1][0].test_attr = 'testing' self.assertTrue(element.initialized, 'Initialized flag should be set to True after initialization') element.init_out_layer(X.shape, y.shape) has_test_attr = hasattr(element.layers[-1][0], 'test_attr') self.assertTrue(has_test_attr, 'New attribute should be still present')
# Dropuoutの有無、割り合いの設定 ======================== use_dropout = True # Dropoutなしのときの場合はFalseに dropout_ratio = 0.15 # ==================================================== network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10, use_dropout=use_dropout, dropout_ration=dropout_ratio) trainer = Trainer(network, x_train, t_train, x_test, t_test, epochs=601, mini_batch_size=100, optimizer='sgd', optimizer_param={'lr': 0.01}, verbose=True) trainer.train() train_acc_list, test_acc_list = trainer.train_acc_list, trainer.test_acc_list # グラフの描画========== markers = {'train': 'o', 'test': 's'} x = np.arange(len(train_acc_list)) plt.plot(x, train_acc_list, marker='o', label='train', markevery=10) plt.plot(x, test_acc_list, marker='s', label='test', markevery=10) plt.xlabel("epochs") plt.ylabel("accuracy")