def main(layers, training_iterations, test_data_file, train_data_file, validate_data_file, data_name): """Run this experiment""" training_ints = base.initialize_instances(train_data_file) testing_ints = base.initialize_instances(test_data_file) validation_ints = base.initialize_instances(validate_data_file) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() # 50 and 0.000001 are the defaults from RPROPUpdateRule.java rule = RPROPUpdateRule(0.064, 50, 0.000001) oa_names = ["RHC"] classification_network = factory.createClassificationNetwork(layers, relu) nnop = NeuralNetworkOptimizationProblem( data_set, classification_network, measure) oa = RandomizedHillClimbing(nnop) base.train(oa, classification_network, 'RHC', training_ints, validation_ints, testing_ints, measure, training_iterations, OUTFILE.format(data_name, 'RHC')) return
def main(layers, training_iterations, test_data_file, train_data_file, validate_data_file, data_name): """Run this experiment""" training_ints = base.initialize_instances(train_data_file) testing_ints = base.initialize_instances(test_data_file) validation_ints = base.initialize_instances(validate_data_file) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() # 50 and 0.000001 are the defaults from RPROPUpdateRule.java rule = RPROPUpdateRule(0.064, 50, 0.000001) oa_names = ["Backprop"] classification_network = factory.createClassificationNetwork(layers, relu) base.train( BatchBackPropagationTrainer(data_set, classification_network, measure, rule), classification_network, 'Backprop', training_ints, validation_ints, testing_ints, measure, training_iterations, OUTFILE.format(data_name, 'Backprop')) return
def main(_): # Init os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" np.random.seed(1) random.seed(a=1, version=2) # Load configuration config = get_parameters(reproduce=None, gpu=-1) print(config) # Load Dataset data = KBDataset(config.data) print(data) # tensorflow config #tf_config = tf.ConfigProto(gpu_options=tf.GPUOptions( # visible_device_list=str(config.gpu))) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True sess = tf.Session(config=tf_config) # Model Loading if config.model == "transe": model = TransE(config, data.nent, data.nrel) else: model = TorusE(config, data.nent, data.nrel) optimizer = tf.train.GradientDescentOptimizer(config.lr) # global_step = tf.Variable(0, name="gb", trainable=False) cal_gradient = optimizer.compute_gradients(model.loss) train_opt = optimizer.apply_gradients(cal_gradient) # Config Saver and Session saver = tf.train.Saver(max_to_keep=100) sess.run(tf.global_variables_initializer()) # Training base.train(data, model, train_opt, config, sess, saver) # Testing base.test(data, model, sess)
def main(P, mate, mutate, layers, training_iterations, test_data_file, train_data_file, validate_data_file, data_name): """Run this experiment""" training_ints = base.initialize_instances(train_data_file) testing_ints = base.initialize_instances(test_data_file) validation_ints = base.initialize_instances(validate_data_file) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() # 50 and 0.000001 are the defaults from RPROPUpdateRule.java rule = RPROPUpdateRule(0.064, 50, 0.000001) oa_name = "GA_{}_{}_{}".format(P, mate, mutate) classification_network = factory.createClassificationNetwork(layers, relu) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) base.train(oa, classification_network, oa_name, training_ints, validation_ints, testing_ints, measure, training_iterations, OUTFILE.format(data_name, oa_name)) return
def main(layers, training_iterations, test_data_file, train_data_file, validate_data_file, data_name): """Run this experiment""" training_ints = base.initialize_instances(train_data_file) testing_ints = base.initialize_instances(test_data_file) validation_ints = base.initialize_instances(validate_data_file) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() # 50 and 0.000001 are the defaults from RPROPUpdateRule.java rule = RPROPUpdateRule(0.064, 50, 0.000001) oa_names = ["Backprop"] classification_network = factory.createClassificationNetwork(layers, relu) with open(OUTFILE.format(data_name, 'Backprop'), 'a+') as f: content = f.read() if "MSE_trg" not in content: f.write('{},{},{},{},{},{},{},{},{},{},{}\n'.format('iteration', 'MSE_trg', 'MSE_val', 'MSE_tst', 'acc_trg', 'acc_val', 'acc_tst', 'f1_trg', 'f1_val', 'f1_tst', 'elapsed')) base.train(BatchBackPropagationTrainer(data_set, classification_network, measure, rule), classification_network, 'Backprop', training_ints, validation_ints, testing_ints, measure, training_iterations, OUTFILE.format(data_name, 'Backprop')) return
def simple_case(): features = [1.0, 3.0, 2.0] weights = [0, 0, 0] goal_pred = 10.0 alpha = 1e-2 times = 100 print(f"goal_prediction={goal_pred}") label = predict(features, weights) print(f"*Before training*") print(f"prediction={label}") print(f"*After training*") weights = train(features, weights, goal_pred, times, alpha) label = predict(features, weights) print(f"prediction={label}") print(f"confidence={round(100-(abs(label-goal_pred))*100/(label+goal_pred), 2)}%") print(f"weights={weights}")
def train(self, goal_pred, inputs, times=500, alpha=0.01): self.weights = train(inputs, self.weights, goal_pred, times, alpha)
import argparse from base import Config, train if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--lr', default=0.01, type=float) parser.add_argument('--ld', default=0.3, type=float) parser.add_argument('--wd', default=0.001, type=float) parser.add_argument('--dr', default=1, type=int) parser.add_argument('--ar', default='peng', type=str) parser.add_argument('--ch', nargs='+', default=(32, 64, 128, 256, 256, 64), type=int) parser.add_argument('--ta', default='ageC', type=str) args = parser.parse_args() cfg = Config(learning_rate=args.lr, lr_decay=args.ld, weight_decay=args.wd, dropout=bool(args.dr), arch=args.ar, channels=args.ch, target=args.ta) train(cfg)
# This also makes training faster, less work to do! fc7 = tf.stop_gradient(fc7) # TODO: Add the final layer for traffic sign classification. nb_classes = 43 shape = (fc7.get_shape().as_list()[-1], nb_classes ) # use this shape for the weight matrix with tf.name_scope("last_layer"): weights = tf.Variable(tf.random_normal(shape, stddev=0.01), name="weights") bias = tf.Variable(tf.zeros(nb_classes), name="bias") logits = tf.add(tf.matmul(fc7, weights), bias) return logits def _create_loss_op(self): one_hot_y = tf.one_hot(self.Y, 43) return tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=self.inference_op, labels=one_hot_y)) # TODO: Train and evaluate the feature extraction model. train(FeatureExtFromAlexNet(), X_train, y_train, X_test, y_test, ckpt="ckpt/cnn")
def train(): """ Train CIFAR-10 for a number of steps. """ with tf.Graph().as_default(): global_step = tf.train.get_or_create_global_step() # Get images and labels for CIFAR-10. # Force input pipeline to CPU:0 to avoid operations sometimes ending up on # GPU and resulting in a slow down. with tf.device('/cpu:0'): images, labels = base.distorted_inputs() # Build a Graph that computes the logits predictions from the # inference model. logits = base.inference(images) # Calculate loss. loss = base.loss(logits, labels) # Build a Graph that trains the model with one batch of examples and # updates the model parameters. train_op = base.train(loss, global_step) class _LoggerHook(tf.train.SessionRunHook): """ Logs loss and runtime. """ def begin(self): self._step = -1 self._start_time = time.time() def before_run(self, run_context): self._step += 1 return tf.train.SessionRunArgs(loss) # Asks for loss value. def after_run(self, run_context, run_values): if self._step % FLAGS.log_frequency == 0: current_time = time.time() duration = current_time - self._start_time self._start_time = current_time loss_value = run_values.results examples_per_sec = FLAGS.log_frequency * FLAGS.batch_size / duration sec_per_batch = float(duration / FLAGS.log_frequency) format_str = ( '%s: step %d, loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch)') print(format_str % (datetime.now(), self._step, loss_value, examples_per_sec, sec_per_batch)) with tf.train.MonitoredTrainingSession( checkpoint_dir=FLAGS.train_dir, hooks=[ tf.train.StopAtStepHook(last_step=FLAGS.max_steps), tf.train.NanTensorHook(loss), _LoggerHook() ], config=tf.ConfigProto(log_device_placement=FLAGS. log_device_placement)) as mon_sess: while not mon_sess.should_stop(): mon_sess.run(train_op)