コード例 #1
0
ファイル: resnet_modify.py プロジェクト: joyivan/cifar_resnet
    def __init__(self, train=False, save=False, load=False):
        self.index = 0
        self.input_placeholder, self.label_placeholder, self.is_training, self.lr = self.input_placeholder(
        )
        #self.logits = self.buildResNet(self.input_placeholder, FLAGS.num_blocks, self.is_training)
        self.logits = self.infer(self.input_placeholder, FLAGS.num_blocks,
                                 self.is_training)
        self.loss, self.total_loss = self.loss(self.logits,
                                               self.label_placeholder)
        self.acc = self.accuracy_op(self.logits, self.label_placeholder)
        self.train_op = self.train_op(self.lr)
        #self.train_op = self.train_op()
        init_op = tf.global_variables_initializer()
        self.sess = tf.Session()
        self.sess.run(init_op)
        self.writer = self.boardWrite()
        #self.load_model()

        self.train_dir = 'output'
        self.model_name = 'resnet'
        self.params = self.get_all_params()
        self.grad_total_loss_op = tf.gradients(self.total_loss, self.params)
        self.grad_loss_no_reg_op = tf.gradients(self.loss, self.params)
        self.v_placeholder = [
            tf.placeholder(tf.float32, shape=a.get_shape())
            for a in self.params
        ]
        self.hessian_vector = hessian_vector_product(self.total_loss,
                                                     self.params,
                                                     self.v_placeholder)
        self.grad_loss_wrt_input_op = tf.gradients(self.total_loss,
                                                   self.input_placeholder)
        self.vec_to_list = self.get_vec_to_list_fn()
        if train:
            self.train()
        if save:
            self.saver = self.save_model()
        if load:
            self.load_model(load_model_dir + "99")
        print("create train_grad_loss_list")
        self.train_grad_loss_list = []
        for i in tqdm(range(50000)):
            temp = np.load(params_dir + "/train_{}.npz".format(i))['loss_val']
            self.train_grad_loss_list.append(temp)
コード例 #2
0
    def __init__(self, **kwargs):
        np.random.seed(0)
        tf.set_random_seed(0)

        self.batch_size = kwargs.pop('batch_size')
        self.data_sets = kwargs.pop('data_sets')
        self.train_dir = kwargs.pop('train_dir', 'output')
        log_dir = kwargs.pop('log_dir', 'log')
        self.model_name = kwargs.pop('model_name')
        self.num_classes = kwargs.pop('num_classes')
        self.initial_learning_rate = kwargs.pop('initial_learning_rate')
        self.decay_epochs = kwargs.pop('decay_epochs')

        if 'keep_probs' in kwargs: self.keep_probs = kwargs.pop('keep_probs')
        else: self.keep_probs = None

        if 'mini_batch' in kwargs: self.mini_batch = kwargs.pop('mini_batch')
        else: self.mini_batch = True

        if 'damping' in kwargs: self.damping = kwargs.pop('damping')
        else: self.damping = 0.0

        if not os.path.exists(self.train_dir):
            os.makedirs(self.train_dir)

        # Initialize session
        config = tf.ConfigProto()
        self.sess = tf.Session(config=config)
        K.set_session(self.sess)

        # Setup input
        self.input_placeholder, self.labels_placeholder = self.placeholder_inputs(
        )
        self.num_train_examples = self.data_sets.train.labels.shape[0]
        self.num_test_examples = self.data_sets.test.labels.shape[0]

        # Setup inference and training
        if self.keep_probs is not None:
            self.keep_probs_placeholder = tf.placeholder(tf.float32, shape=(2))
            self.logits = self.inference(self.input_placeholder,
                                         self.keep_probs_placeholder)
        elif hasattr(self, 'inference_needs_labels'):
            self.logits = self.inference(self.input_placeholder,
                                         self.labels_placeholder)
        else:
            self.logits = self.inference(self.input_placeholder)

        self.total_loss, self.loss_no_reg, self.indiv_loss_no_reg = self.loss(
            self.logits, self.labels_placeholder)

        self.global_step = tf.Variable(0, name='global_step', trainable=False)
        self.learning_rate = tf.Variable(self.initial_learning_rate,
                                         name='learning_rate',
                                         trainable=False)
        self.learning_rate_placeholder = tf.placeholder(tf.float32)
        self.update_learning_rate_op = tf.assign(
            self.learning_rate, self.learning_rate_placeholder)

        #        self.train_op = self.get_train_op(self.total_loss, self.global_step, self.learning_rate)
        self.train_op = self.get_train_sgd_op(self.total_loss,
                                              self.global_step,
                                              self.learning_rate)
        self.accuracy_op = self.get_accuracy_op(self.logits,
                                                self.labels_placeholder)
        self.preds = self.predictions(self.logits)

        # Setup misc
        self.saver = tf.train.Saver()

        # Setup gradients and Hessians
        self.params = self.get_all_params()
        self.grad_total_loss_op = tf.gradients(self.total_loss, self.params)
        self.grad_loss_no_reg_op = tf.gradients(self.loss_no_reg, self.params)
        self.v_placeholder = [
            tf.placeholder(tf.float32, shape=a.get_shape())
            for a in self.params
        ]
        self.u_placeholder = [
            tf.placeholder(tf.float32, shape=a.get_shape())
            for a in self.params
        ]

        self.hessian_vector = hessian_vector_product(self.total_loss,
                                                     self.params,
                                                     self.v_placeholder)

        self.grad_loss_wrt_input_op = tf.gradients(self.total_loss,
                                                   self.input_placeholder)

        # Because tf.gradients auto accumulates, we probably don't need the add_n (or even reduce_sum)
        self.influence_op = tf.add_n([
            tf.reduce_sum(tf.multiply(a, array_ops.stop_gradient(b)))
            for a, b in zip(self.grad_total_loss_op, self.v_placeholder)
        ])

        self.grad_influence_wrt_input_op = tf.gradients(
            self.influence_op, self.input_placeholder)

        self.checkpoint_file = os.path.join(self.train_dir,
                                            "%s-checkpoint" % self.model_name)

        self.all_train_feed_dict = self.fill_feed_dict_with_all_ex(
            self.data_sets.train)
        self.all_test_feed_dict = self.fill_feed_dict_with_all_ex(
            self.data_sets.test)

        init = tf.global_variables_initializer()
        self.sess.run(init)

        self.vec_to_list = self.get_vec_to_list_fn()
        self.adversarial_loss, self.indiv_adversarial_loss = self.adversarial_loss(
            self.logits, self.labels_placeholder)
        if self.adversarial_loss is not None:
            self.grad_adversarial_loss_op = tf.gradients(
                self.adversarial_loss, self.params)
コード例 #3
0
# Setup misc
saver = tf.train.Saver()

all_params = []
for layer in ['softmax_linear']:
    for var_name in ['weights']:                
        temp_tensor = tf.get_default_graph().get_tensor_by_name("%s/%s:0" % (layer, var_name))            
        all_params.append(temp_tensor)      
params=all_params

grad_total_loss_op = tf.gradients(total_loss, params)
grad_loss_no_reg_op =tf.gradients(loss_no_reg,params)
v_placeholder = [tf.placeholder(tf.float32, shape=a.get_shape()) for a in params]
u_placeholder = [tf.placeholder(tf.float32, shape=a.get_shape()) for a in params]
hessian_vector = hessian_vector_product(total_loss, params, v_placeholder)
grad_loss_wrt_input_op = tf.gradients(total_loss, input_placeholder)        

influence_op = tf.add_n(
    [tf.reduce_sum(tf.multiply(a, array_ops.stop_gradient(b))) for a, b in zip(grad_total_loss_op, v_placeholder)])

grad_influence_wrt_input_op = tf.gradients(influence_op, input_placeholder)
checkpoint_file = os.path.join(train_dir, "%s-checkpoint" % model_name)

# Here I have reduced number of datapoints learned in the train().
all_train_feed_dict = {input_placeholder: data_sets.train.x,labels_placeholder: data_sets.train.labels}
all_test_feed_dict = {input_placeholder: data_sets.test.x,labels_placeholder: data_sets.test.labels}

init = tf.global_variables_initializer()        
sess.run(init)