Exemplo n.º 1
0
    def setup_graphs(self):

        # Create shared network
        s, policy_network, value_network = self.model_factory(self, self.env[0], **self.kwargs)
        policy_network_params = policy_network.trainable_weights
        value_network_params = value_network.trainable_weights
        pi_values = policy_network(s)
        V_values = value_network(s)

        # Create shared target network
        st, target_policy_network, target_value_network = self.model_factory(self, self.env[0])
        target_policy_network_params = target_policy_network.trainable_weights
        target_value_network_params = target_value_network.trainable_weights
        target_pi_values = target_policy_network(st)
        target_V_values = target_value_network(st)

        # Op for periodically updating target network with online network weights
        reset_local_policy_network_params = [policy_network_params[i].assign(target_policy_network_params[i]) for i in range(len(policy_network_params))]
        reset_local_value_network_params = [value_network_params[i].assign(target_value_network_params[i]) for i in range(len(value_network_params))]
        reset_target_policy_network_params = [target_policy_network_params[i].assign(policy_network_params[i]) for i in range(len(target_policy_network_params))]
        reset_target_value_network_params = [target_value_network_params[i].assign(value_network_params[i]) for i in range(len(target_value_network_params))]

        # Define A3C cost and gradient update equations
        a = tf.placeholder("float", [None, self.env[0].action_space.n])
        R = tf.placeholder("float", [None, 1])
        action_pi_values = tf.reduce_sum(tf.mul(pi_values, a), reduction_indices=1)

        # policy network update
        cost_pi = -K.log( tf.reduce_sum(  action_pi_values ) ) * (R-V_values)
        #optimizer_pi = keras.optimizers.Adam(self.learning_rate, clipvalue=1e3)
        optimizer_pi = tf.train.RMSPropOptimizer(self.learning_rate)
        grad_update_pi = optimizer_pi.minimize(cost_pi, var_list=policy_network_params)
        grad_pi = K.gradients(cost_pi, policy_network_params)

        # value network update
        cost_V = tf.reduce_mean( tf.square( R - V_values ) )
        #optimizer_V = keras.optimizers.Adam(self.learning_rate, clipvalue=1e3)
        optimizer_V = tf.train.RMSPropOptimizer(self.learning_rate)
        grad_update_V = optimizer_V.minimize(cost_V, var_list=value_network_params)
        grad_V = K.gradients(cost_V, value_network_params)

        # store variables and update functions for access
        self.graph_ops = {
                 "R" : R,
                 "s" : s,
                 "pi_values" : pi_values,
                 "V_values" : V_values,
                 "st" : st,
                 "reset_target_policy_network_params" : reset_target_policy_network_params,
                 "reset_target_value_network_params" : reset_target_value_network_params,
                 "reset_local_policy_network_params" : reset_local_policy_network_params,
                 "reset_local_value_network_params" : reset_local_value_network_params,
                 "a" : a,
                 "grad_update_pi" : grad_update_pi,
                 "cost_pi" : cost_pi,
                 "grad_pi" : grad_pi,
                 "grad_update_V" : grad_update_V,
                 "cost_V" : cost_V,
                 "grad_V" : grad_V
                }
Exemplo n.º 2
0
    def setup_graphs(self):

        # update network weights...
        set_weights_v = lambda x: [value_network_params[i].assign(x[i]) for i in range(len(x))]
        set_weights_p = lambda x: [policy_network_params[i].assign(x[i]) for i in range(len(x))]
        
        # Create shared network
        s, policy_network, value_network = self.model_factory(self, self.env[0], **self.kwargs)
        policy_network_params = policy_network.trainable_weights
        value_network_params = value_network.trainable_weights
        pi_values = policy_network(s)
        V_values = value_network(s)

        # Define A3C cost and gradient update equations
        a = tf.placeholder("float", [None, self.env[0].action_space.n])
        R = tf.placeholder("float", [None, 1])
        action_pi_values = tf.reduce_sum(tf.mul(pi_values, a), reduction_indices=1)

        # policy network update
        cost_pi = -K.log( tf.reduce_sum(  action_pi_values ) ) * (R-V_values)
        #optimizer_pi = keras.optimizers.Adam(self.learning_rate, clipvalue=1e3)
        optimizer_pi = tf.train.RMSPropOptimizer(self.learning_rate)
        grad_update_pi = optimizer_pi.minimize(cost_pi, var_list=policy_network_params)
        grad_pi = K.gradients(cost_pi, policy_network_params)

        # value network update
        cost_V = tf.reduce_mean( tf.square( R - V_values ) )
        #optimizer_V = keras.optimizers.Adam(self.learning_rate, clipvalue=1e3)
        optimizer_V = tf.train.RMSPropOptimizer(self.learning_rate)
        grad_update_V = optimizer_V.minimize(cost_V, var_list=value_network_params)
        grad_V = K.gradients(cost_V, value_network_params)

        # store variables and update functions for access
        self.graph_ops = {
                 "R" : R,
                 "s" : s,
                 "pi_values" : pi_values,
                 "V_values" : V_values,
                 "a" : a,

                 # policy network 
                 "grad_update_pi" : grad_update_pi,
                 "cost_pi" : cost_pi,
                 "grad_pi" : grad_pi,

                 # value network 
                 "grad_update_V" : grad_update_V,
                 "cost_V" : cost_V,
                 "grad_V" : grad_V,

                 "w_p" : policy_network.get_weights,
                 "w_v" : value_network.get_weights,
                 "set_weights_p" : set_weights_p,
                 "set_weights_v" : set_weights_v,
                }
Exemplo n.º 3
0
    def __init__(self, input_tensor, losses, input_range=(0, 255), wrt_tensor=None, norm_grads=True):
        """Creates an optimizer that minimizes weighted loss function.

        Args:
            input_tensor: An input tensor of shape: `(samples, channels, image_dims...)` if `image_data_format=
                channels_first` or `(samples, image_dims..., channels)` if `image_data_format=channels_last`.
            losses: List of ([Loss](vis.losses#Loss), weight) tuples.
            input_range: Specifies the input range as a `(min, max)` tuple. This is used to rescale the
                final optimized input to the given range. (Default value=(0, 255))
            wrt_tensor: Short for, with respect to. This instructs the optimizer that the aggregate loss from `losses`
                should be minimized with respect to `wrt_tensor`.
                `wrt_tensor` can be any tensor that is part of the model graph. Default value is set to None
                which means that loss will simply be minimized with respect to `input_tensor`.
            norm_grads: True to normalize gradients. Normalization avoids very small or large gradients and ensures
                a smooth gradient gradient descent process. If you want the actual gradient
                (for example, visualizing attention), set this to false.
        """
        self.input_tensor = input_tensor
        self.input_range = input_range
        self.loss_names = []
        self.loss_functions = []
        self.wrt_tensor = self.input_tensor if wrt_tensor is None else wrt_tensor
        if self.input_tensor is self.wrt_tensor:
            self.wrt_tensor_is_input_tensor = True
            self.wrt_tensor = K.identity(self.wrt_tensor)
        else:
            self.wrt_tensor_is_input_tensor = False

        overall_loss = None
        for loss, weight in losses:
            # Perf optimization. Don't build loss function with 0 weight.
            if weight != 0:
                loss_fn = weight * loss.build_loss()
                overall_loss = loss_fn if overall_loss is None else overall_loss + loss_fn
                self.loss_names.append(loss.name)
                self.loss_functions.append(loss_fn)

        # Compute gradient of overall with respect to `wrt` tensor.
        if self.wrt_tensor_is_input_tensor:
            grads = K.gradients(overall_loss, self.input_tensor)[0]
        else:
            grads = K.gradients(overall_loss, self.wrt_tensor)[0]
        if norm_grads:
            grads = K.l2_normalize(grads)

        # The main function to compute various quantities in optimization loop.
        self.compute_fn = K.function([self.input_tensor, K.learning_phase()],
                                     self.loss_functions + [overall_loss, grads, self.wrt_tensor])
Exemplo n.º 4
0
def EvaluateJacobian(model):
	#theano.function( [model.layers[0].input], T.jacobian(model.layers[-1].output.flatten(), model.layers[0].input) )


	X = K.placeholder(shape=(15,15)) #specify the right placeholder
	Y = K.sum(K.square(X)) # loss function
	fn = K.function([X], K.gradients(Y, [X])) #function to call the gradient
Exemplo n.º 5
0
def build_train_fn(model):
    # cost
    lr = T.scalar()
    labels = K.placeholder(ndim=2, dtype='int32')
    ob_input = model.inputs[0]
    raw_softmax_outputs = model.outputs[0]

    softmax_outputs = raw_softmax_outputs.dimshuffle((2,0,1))
    softmax_outputs = softmax_outputs.reshape((softmax_outputs.shape[0], softmax_outputs.shape[1]*softmax_outputs.shape[2]))
    softmax_outputs = softmax_outputs.dimshuffle((1,0))

    cost = categorical_crossentropy(softmax_outputs, labels).mean()

    # gradients
    trainable_vars = model.trainable_weights
    grads = K.gradients(cost, trainable_vars)
    grads = lasagne.updates.total_norm_constraint(grads, 100)
    updates = lasagne.updates.nesterov_momentum(grads, trainable_vars, lr, 0.99)

    for key, val in model.updates:                              
        updates[key] = val

    # train_fn
    train_fn = K.function([ob_input, labels, K.learning_phase(), lr],
                          [softmax_outputs, cost],
                          updates=updates)

    return train_fn
Exemplo n.º 6
0
    def build_model(self):
        """Build a Critic (Value) model that maps (state, action)> Q_values."""
        # Input layers
        states = layers.Input(shape=(self.state_size,), name="states")
        actions = layers.Input(shape=(self.action_size,), name="actions")

        # Add some hidden layers to state pathway
        net_states = layers.Dense(units=32, activation="relu")(states)
        net_states = layers.Dense(units=64, activation="relu")(net_states)

        # Add some hidden layers to action pathway
        net_actions = layers.Dense(units=32, activation="relu")(actions)
        net_actions = layers.Dense(units=64, activation="relu")(net_actions)

        # Combine both pathways
        net = layers.Add()([net_states, net_actions])
        net = layers.Activation('relu')(net)

        Q_values = layers.Dense(units=1, name='q_values')(net)

        self.model = models.Model(inputs=[states, actions], outputs=Q_values)

        optimizer = optimizers.Adam()
        self.model.compile(optimizer=optimizer, loss='mse')

        # Compute action gradients (derivative of Q values w.r.t. to actions)
        action_gradients = K.gradients(Q_values, actions)

        # Define an additional function to fetch action gradients (to be used
        # by actor model)
        self.get_action_gradients = K.function(
            inputs=[*self.model.inputs, K.learning_phase()],
            outputs=action_gradients)
Exemplo n.º 7
0
    def __init__(
            self, x_dim, u_dim, r_dim, model_path=None, model=None
    ):
        print("Init ForwardDynamicsAndRewardDNN")
        super(ForwardDynamicsAndRewardDNN, self).__init__(
            x_dim, u_dim, r_dim
        )

        if model_path is not None:
            self.mdl = load_model(
                model_path,
                custom_objects={'atan2_loss': atan2_loss, 'cos': KK.cos}
            )

        if model is not None:
            self.mdl = model

        x0 = KK.placeholder(shape=(None, self.x_dim), name='x0')
        u = KK.placeholder(shape=(None, self.u_dim), name='u')
        x1, cost = self.mdl([x0, u])
        samp_symb = KK.placeholder(
            shape=(1, self.x_dim),
            name='samp_syb'
        )
        loss = KK.expand_dims(mse(samp_symb, x1), axis=1)
        u_grads = KK.gradients([loss], [u])

        self.meas_fn = KK.function(
            [x0, u, samp_symb],
            [x1, loss] + u_grads
        )

        self.zero_control = None
Exemplo n.º 8
0
def calc_loss_grad(model, combo_img, img_width, img_height):
    # get the symbolic outputs of each "key" layer
    outputs_dict = dict([(layer.name, layer.output) \
                        for layer in model.layers \
                        if layer.name[:5] == 'conv_'])

    # combine these loss functions into a single scalar
    loss = K.variable(0.)

    # content loss
    # use last non-fully-connected layer
    layer_feats = outputs_dict[last_layer]
    base_feats = layer_feats[0, :, :, :]
    combo_feats = layer_feats[2, :, :, :]
    cl = content_loss(base_feats, combo_feats)
    loss += content_weight * cl

    # style loss and spatial loss
    for name in outputs_dict:
        layer_feats = outputs_dict[name]
        style_feats = layer_feats[1, :, :, :]
        combo_feats = layer_feats[2, :, :, :]
        spatial = spatial_loss(style_feats, combo_feats)
        sl = style_loss(style_feats, combo_feats, img_width, img_height)
        loss += (spatial_weight / len(outputs_dict)) * spatial
        loss += (style_weight / len(outputs_dict)) * sl

    # single scalar loss
    loss += total_variation_weight * \
            total_variation_loss(combo_img, img_width, img_height)

    # get the gradients of the generated image wrt the loss
    grads = K.gradients(loss, combo_img)

    return loss, grads
Exemplo n.º 9
0
def process_conv_2d_layer(layer, input_img):
    """Generate images maximizing the activation of conv2d filters"""
    filter_cnt = layer.get_weights()[0].shape[-1]
    img_width, img_height, img_chans = input_img.shape[1:4]
    kept_filters = []
    for filter_index in range(filter_cnt):
        print('{}:, filter {} of {}'.format(
            layer.name, filter_index, filter_cnt))

        # we build a loss function that maximizes the activation
        # of the nth filter of the layer considered
        loss = K.mean(layer.output[:, :, :, filter_index])

        # we compute the gradient of the input picture wrt this loss
        grads = K.gradients(loss, input_img)[0]

        # normalization trick: we normalize the gradient
        grads = normalize(grads)

        # this function returns the loss and grads given the input picture
        iterate = K.function([input_img], [loss, grads])

        # we start from a gray image with some random noise
        input_img_data = np.random.random((1, img_width, img_height, img_chans))

        # run gradient ascent
        for _ in range(GRADIENT_ASCENT_STEPS):
            loss_value, grads_value = iterate([input_img_data])
            input_img_data += grads_value * GRADIENT_ASCENT_STEP_SIZE

        # decode the resulting input image
        img = deprocess_image(input_img_data[0])
        kept_filters.append((img, loss_value))

    return kept_filters
Exemplo n.º 10
0
def grad_cam(input_model, model_x, orig_x, category_index, layer_name, class_names):
    output = input_model.output

    final_layer = Lambda(lambda x: target_category_loss(x, category_index, len(class_names)))
    output = final_layer(output)
    model = Model(inputs=input_model.input, outputs=output)
    loss = K.sum(model.layers[-1].output)
    conv_output = model.get_layer(layer_name).output
    grads = normalize(K.gradients(loss, conv_output)[0])
    gradient_function = K.function([model.layers[0].input, K.learning_phase()], [conv_output, grads])
    output, grads_val = gradient_function([model_x, 0])

    output, grads_val = output[0, :], grads_val[0, :, :, :]

    weights = np.mean(grads_val, axis=(0, 1))
    cam = np.zeros(output.shape[0: 2], dtype=np.float32)

    for i, w in enumerate(weights):
        cam += w * output[:, :, i]

    cam = np.maximum(cam, np.zeros(output.shape[0: 2], dtype=np.float32))
    cam = cam.squeeze()
    cam = cv2.applyColorMap(np.uint8(255 * cam / np.max(cam)), cv2.COLORMAP_JET)
    cam = cv2.resize(cam, (np.shape(orig_x)[0], np.shape(orig_x)[1]))
    cam = 0.4 * cam + 0.6 * orig_x
    return np.uint8(cam)
Exemplo n.º 11
0
def compile_saliency_function(model, activation_layer='block5_conv3'):
    input_img = model.input
    layer_dict = dict([(layer.name, layer) for layer in model.layers[1:]])
    layer_output = layer_dict[activation_layer].output
    max_output = K.max(layer_output, axis=3)
    saliency = K.gradients(K.sum(max_output), input_img)[0]
    return K.function([input_img, K.learning_phase()], [saliency])
Exemplo n.º 12
0
    def call(self):
        E = K.variable(np.random.random((1000,100)), name="entity_embeddings")
        R = K.variable(np.random.random((10,10000)), name="relation_embeddings")
        x = K.placeholder(shape=(1,3), name="spo")
        y = K.placeholder(ndim=0, name="y")
        batch_placeholder = K.cast(x, 'int32')[0]
        # print(batch_placeholder.eval())
        s, o, p = [batch_placeholder[i] for i in range(3)]

        s2v = K.gather(E, s)
        o2v = K.gather(E, o)
        r2v = K.gather(R, p)

        def ccorr(a, b):
            return T.outer(a,b).flatten()
            # return T.arctan(s2v) + T.arctan(o2v)
            # return (s2v.dimshuffle('x', 'x', 0, 'x') + o2v.dimshuffle('x', 'x', 0, 'x')).flatten()
            # return T.nnet.conv2d(a.dimshuffle('x', 'x', 0, 'x'), b.dimshuffle('x', 'x', 0, 'x'), None,
            #                None,
            #                filter_flip=True, border_mode='half')
            # return self.ccorr1d_sc(a, b, border_mode='half')
        eta = K.dot(r2v, ccorr(s2v, o2v))
        # py = 1/(1+K.exp(-eta))
        # l = -K.log(py)
        # from theano import pp, function, printing
        # grad = T.grad(eta, E)
        # print(pp(grad))
        # func = function([x], grad)
        func = K.function([x, y], K.gradients(eta, [s2v, o2v, r2v, E, R]))

        # for i in func.maker.fgraph.outputs:
            # print(pp(i))
        # print (T.grad(py, s2v))
        print (func([[[1,2,3]], -1]))
Exemplo n.º 13
0
def gradient_penalty_loss(y_true, y_pred, averaged_samples, gradient_penalty_weight):
    """Calculates the gradient penalty loss for a batch of "averaged" samples.

    In Improved WGANs, the 1-Lipschitz constraint is enforced by adding a term to the loss function
    that penalizes the network if the gradient norm moves away from 1. However, it is impossible to evaluate
    this function at all points in the input space. The compromise used in the paper is to choose random points
    on the lines between real and generated samples, and check the gradients at these points. Note that it is the
    gradient w.r.t. the input averaged samples, not the weights of the discriminator, that we're penalizing!

    In order to evaluate the gradients, we must first run samples through the generator and evaluate the loss.
    Then we get the gradients of the discriminator w.r.t. the input averaged samples.
    The l2 norm and penalty can then be calculated for this gradient.

    Note that this loss function requires the original averaged samples as input, but Keras only supports passing
    y_true and y_pred to loss functions. To get around this, we make a partial() of the function with the
    averaged_samples argument, and use that for model training."""
    # first get the gradients:
    #   assuming: - that y_pred has dimensions (batch_size, 1)
    #             - averaged_samples has dimensions (batch_size, nbr_features)
    # gradients afterwards has dimension (batch_size, nbr_features), basically
    # a list of nbr_features-dimensional gradient vectors
    gradients = K.gradients(y_pred, averaged_samples)[0]
    # compute the euclidean norm by squaring ...
    gradients_sqr = K.square(gradients)
    #   ... summing over the rows ...
    gradients_sqr_sum = K.sum(gradients_sqr,
                              axis=np.arange(1, len(gradients_sqr.shape)))
    #   ... and sqrt
    gradient_l2_norm = K.sqrt(gradients_sqr_sum)
    # compute lambda * (1 - ||grad||)^2 still for each single sample
    gradient_penalty = gradient_penalty_weight * K.square(1 - gradient_l2_norm)
    # return the mean as loss over all the batch samples
    return K.mean(gradient_penalty)
Exemplo n.º 14
0
def get_grad(gen_image_array):
    '''计算损失函数的梯度'''
    if gen_image_array != (1, target_width, target_height, 3):
        gen_image_array = gen_image_array.reshape((1, target_width, target_height, 3))
    grad_fn = K.function([gModel.input], K.gradients(get_total_loss(gModel.input), [gModel.input]))
    grad = grad_fn([gen_image_array])[0].flatten().astype('float64')
    return grad
Exemplo n.º 15
0
def visualize_mser_classifier():
	model = load_model('mser_classifier')
	# Get the symbolic outputs of each "key" layer
	layer_dict = dict([(layer.name, layer) for layer in model.layers])
	layer_name = 'block5_conv3'
	# Can be any integer from 0 to 511, as there are 512 filters in that layer
	kept_filters = []
	for filter_index in range(200):
		print(filter_index)
		# Loss function that maximizes the activation
		# of the nth filter of the layer considered
		layer_output = layer_dict[layer_name].output
		loss = K.mean(layer_output[:, :, :, filter_index])
		# Placeholder for the input images
		input_img = model.input
		# Dimensions of the generated pictures for each filter.
		img_width = 128
		img_height = 128
		# Compute the gradient of the input picture wrt this loss
		grads = K.gradients(loss, input_img)[0]
		# Normalize the gradient
		grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5)
		# This function returns the loss and grads given the input picture
		iterate = K.function([input_img], [loss, grads])
		# Step size for gradient ascent
		step = 1
		# Start with a random gray image
		input_img_data = np.random.random((1, img_width, img_height, 3)) * 20 + 128
		# run gradient ascent for 20 steps
		for i in range(20):
		    loss_value, grads_value = iterate([input_img_data])
		    input_img_data += grads_value * step
		    print('Current loss value:', loss_value)
		    if loss_value <= 0.:
		    	# some filters get stuck to 0, we can skip them
		    	break
		# Append generated image
		if loss_value > 0:
			img = deprocess_image(input_img_data[0])
			kept_filters.append((img, loss_value))
	# Stich the best 16 filters on a 4 x 4 grid
	n = 4
	# The filters that have the highest loss are assumed to be better-looking.
	# Keep the best 64 filters.
	kept_filters.sort(key=lambda x: x[1], reverse=True)
	kept_filters = kept_filters[:n * n]
	# Build a black picture with enough space for
	# all 4 x 4 filters of size 128 x 128, with a 5px margin in between
	margin = 5
	width = n * img_width + (n - 1) * margin
	height = n * img_height + (n - 1) * margin
	stitched_filters = np.zeros((width, height, 3))
	# Fill the picture with the saved filters
	for i in range(n):
	    for j in range(n):
	        img, loss = kept_filters[i * n + j]
	        stitched_filters[(img_width + margin) * i: (img_width + margin) * i + img_width,
	                         (img_height + margin) * j: (img_height + margin) * j + img_height, :] = img
	# Save the result to disk
	imsave('mser_classifier_stitched_filters_%dx%d.png' % (n, n), stitched_filters)
Exemplo n.º 16
0
    def visualize_layer(self, layer, model, keep_filters, out_path, vis_size):
        layer_output = layer.output
        num_filters = layer.nb_filter
        filters = []
        img_width = vis_size[0]
        img_height = vis_size[1]

        for filter_index in xrange(num_filters):
            loss = K.mean(K.mean(layer_output[:, filter_index, :, :]))

            # compute the gradient of the input picture wrt this loss
            grads = K.gradients(loss, model.layers[0].input)[0]

            # normalization trick: we normalize the gradient
            grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5)

            # this function returns the loss and grads given the input picture
            iterate = K.function([model.layers[0].input], [loss, grads])

            # step size for gradient ascent
            step = 1.

            input_img_data = np.random.random((1, 1, img_width, img_height)) * 20 + 128.

            for i in xrange(50):
                loss_value, grads_value = iterate([input_img_data])
                input_img_data += grads_value * step

                if loss_value <= 0:
                    break

            img = self.deprocess_image(input_img_data[0])
            filters.append((img, loss_value))

        filters.sort(key=lambda x: x[1], reverse=True)
        filters = filters[:keep_filters]

        # get number of grid rows and columns
        grid_r, grid_c = helpers.get_grid_dim(keep_filters)

        # create figure and axes
        fig, axes = plt.subplots(min([grid_r, grid_c]),
                                 max([grid_r, grid_c]))


        # iterate filters inside every channel
        for l, ax in enumerate(axes.flat):
            # get a single filter
            img = filters[l][0][:, :, 0]
            # put it on the grid
            ax.imshow(img, interpolation='bicubic', cmap='Greys')
            # remove any labels from the axes
            ax.set_xticks([])
            ax.set_yticks([])
        # save figure
        out_path = os.path.join(out_path, layer.name) + '.png'
        plt.savefig(out_path, bbox_inches='tight')

        """
Exemplo n.º 17
0
 def get_gradients(self, loss, params):
     grads = K.gradients(loss, params)
     if hasattr(self, 'clipnorm') and self.clipnorm > 0:
         norm = K.sqrt(sum([K.sum(K.square(g)) for g in grads]))
         grads = [clip_norm(g, self.clipnorm, norm) for g in grads]
     if hasattr(self, 'clipvalue') and self.clipvalue > 0:
         grads = [K.clip(g, -self.clipvalue, self.clipvalue) for g in grads]
     return grads
Exemplo n.º 18
0
   def call(self, x, mask=None):
       output = K.resize_images(x, self.size[0], self.size[1], 
                                self.dim_ordering)
 
       f = K.gradients(K.sum(self._master_layer.output), 
                       self._master_layer.input) * output
 
       return f
Exemplo n.º 19
0
    def XXXget_cost_grads_symbolic(self):
        """ Returns symbolic cost and symbolic gradients for the model """
        trainable_params = self._get_trainable_params(self.model)

        #cost = self.model.model.total_loss
        cost = self.model.total_loss
        grads = K.gradients(cost, trainable_params)

        return cost, grads
Exemplo n.º 20
0
    def get_cost_grads(self):
        """ Returns the cost and flattened gradients for the model """
        model = self.model
        trainable_params = self.get_trainable_params()

        #cost = model.model.total_loss
        cost = model.total_loss
        grads = K.gradients(cost, trainable_params)

        return cost, grads
Exemplo n.º 21
0
 def get_gradients(self, loss, params):
     grads = K.gradients(loss, params)
     if hasattr(self, 'scale') and self.scale != 1:
         grads = [g*K.variable(self.scale) for g in grads]
     if hasattr(self, 'clipnorm') and self.clipnorm > 0:
         norm = K.sqrt(sum([K.sum(K.square(g)) for g in grads]))
         grads = [K.switch(norm >= self.clipnorm, g * self.clipnorm / norm, g) for g in grads]
     if hasattr(self, 'clipvalue') and self.clipvalue > 0:
         grads = [K.clip(g, -self.clipvalue, self.clipvalue) for g in grads]
     return grads
Exemplo n.º 22
0
 def build(self, a_image, ap_image, b_image, output_shape):
     self.output_shape = output_shape
     loss = self.build_loss(a_image, ap_image, b_image)
     # get the gradients of the generated image wrt the loss
     grads = K.gradients(loss, self.net_input)
     outputs = [loss]
     if type(grads) in {list, tuple}:
         outputs += grads
     else:
         outputs.append(grads)
     self.f_outputs = K.function([self.net_input], outputs)
Exemplo n.º 23
0
    def build_model(self):
        """Build a critic (value) network that maps (state, action) pairs -> Q-values."""
        # Define input layers
        states = layers.Input(shape=(self.state_size,), name='states')
        actions = layers.Input(shape=(self.action_size,), name='actions')

        # Add hidden layer(s) for state pathway
        net_states = layers.Dense(units=512, kernel_initializer=layers.initializers.RandomUniform(minval=-0.003, maxval=0.003))(states)
        net_states = layers.normalization.BatchNormalization()(net_states)
        net_states = layers.Activation('relu')(net_states)
        net_states = layers.Dense(units=256, kernel_initializer=layers.initializers.RandomUniform(minval=-0.003, maxval=0.003))(net_states)
        net_states = layers.normalization.BatchNormalization()(net_states)
        net_states = layers.Activation('relu')(net_states)
        net_states = layers.Dense(units=128, kernel_initializer=layers.initializers.RandomUniform(minval=-0.003, maxval=0.003))(net_states)
        net_states = layers.normalization.BatchNormalization()(net_states)

        # Add hidden layer(s) for action pathway
        net_actions = layers.Dense(units=256, kernel_initializer=layers.initializers.RandomUniform(minval=-0.003, maxval=0.003))(actions)
        net_actions = layers.normalization.BatchNormalization()(net_actions)
        net_actions = layers.Activation('relu')(net_actions)
        net_actions = layers.Dense(units=128, kernel_initializer=layers.initializers.RandomUniform(minval=-0.003, maxval=0.003))(net_actions)
        net_actions = layers.normalization.BatchNormalization()(net_actions)

        # Try different layer sizes, activations, add batch normalization, regularizers, etc.
        

        # Combine state and action pathways
        net = layers.Add()([net_states, net_actions])
        net = layers.Activation('relu')(net)
        
        # Add more layers to the combined network if needed
        net = layers.Dense(units=512, kernel_initializer=layers.initializers.RandomUniform(minval=-0.003, maxval=0.003))(net)
        net = layers.normalization.BatchNormalization()(net)
        net = layers.Activation('relu')(net)


        # Add final output layer to prduce action values (Q values)
        Q_values = layers.Dense(units=1, kernel_initializer=layers.initializers.RandomUniform(minval=-0.003, maxval=0.003), 
            name='q_values')(net)

        # Create Keras model
        self.model = models.Model(inputs=[states, actions], outputs=Q_values)

        # Define optimizer and compile model for training with built-in loss function
        optimizer = optimizers.Adam(self.CRITIC_LEARNING_RATE)
        self.model.compile(optimizer=optimizer, loss='mse')

        # Compute action gradients (derivative of Q values w.r.t. to actions)
        action_gradients = K.gradients(Q_values, actions)

        # Define an additional function to fetch action gradients (to be used by actor model)
        self.get_action_gradients = K.function(
            inputs=[*self.model.input, K.learning_phase()],
            outputs=action_gradients)
Exemplo n.º 24
0
 def compile_get_grads(self):
     scalar_objective = self.sum_objectives(self.objectives)
     self.grads_positions = [{} for _ in self.params]
     objectives = copy.copy(self.objectives)
     objectives[self.name] = scalar_objective
     self.evaluate_objective_names = list(objectives.keys())
     gradients = []
     for name, objective in objectives.items():
         for i, grad in enumerate(K.gradients(objective, self.params)):
             self.grads_positions[i][name] = len(gradients)
             gradients.append(grad)
     self._gradients_fn = theano.function(self.inputs, gradients)
Exemplo n.º 25
0
def compute_gradients(t_loss, param_list, t_inputs, n_inputs):
    """ Computes the derivaties of out (either loss or just Q) wrt the params and returns a flat np array
        NOTE: Make sure that params is a flat list (get using get_trainable_weights for eg)
              Make sure all necessary inputs for the grad computation is present in inputs
              t_inputs is the tensor inputs; and n_inputs is the numeric version """
    # Iterate over each sets of weights in params
    x = np.empty(0)
    for param in param_list:
        c_grad = K.function(t_inputs, K.gradients(t_loss, [param]))
        grad = c_grad(n_inputs) # this is a list
        grad = np.asarray(grad).reshape(-1) # make it into flat array
        x = np.concatenate([x, grad])
    return x
Exemplo n.º 26
0
 def build(self, a_image, ap_image, b_image, output_shape):
     self.output_shape = output_shape
     loss = self.build_loss(a_image, ap_image, b_image)
     # get the gradients of the generated image wrt the loss
     grads = K.gradients(loss, self.net_input)
     outputs = [loss]
     if type(grads) in {list, tuple}:
         outputs += grads
     else:
         outputs.append(grads)
     f_inputs = [self.net_input]
     for nnf in self.feature_nnfs:
         f_inputs.append(nnf.placeholder)
     self.f_outputs = K.function(f_inputs, outputs)
def main():
    # Use gradient-descend to minimize the confidence of the "good" prediction
    lenet = LeNet()
    print(lenet._model.layers)
    # SoftMax activation on the last layer shrinks our gradients so much it is impossible to
    # do floating point computation, so we just peel it off from the output
    sym_outouts = layer_without_activation(lenet._model.layers[-1])
    print("sym_outouts", sym_outouts)
    sym_inputs = lenet._model.inputs[0]
    print("sym_inputs", sym_inputs)

    for image_index in range(8):
        # K.set_floatx('float64')

        imageori = plt.imread("static/{}.jpg".format(image_index)).copy().astype("float")

        output_path = "broken/{}.jpg".format(image_index)

        original_prediction = predictimg(imageori, lenet)
        original_prediction_index = original_prediction[0]

        loss = -sym_outouts[0][original_prediction_index]
        # print("LOSS", loss)
        fn = K.function([sym_inputs], K.gradients(loss, sym_inputs))

        imagenew = imageori.copy()
        for i in range(100):
            bump = fn([[imagenew]])[0][0]
            imagenew = np.clip(imagenew.copy() + bump, 0, 255)

            # saving to jpg alters the image so check whether our prediction is broken after a reload
            plt.imsave(output_path, imagenew.astype("uint8"), format="jpg")
            broken = plt.imread(output_path)

            new_prediction = predictimg(broken, lenet)
            # print("ITER", mse(imagenew, imageori))
            if new_prediction[0] != original_prediction_index:
                break
        else:
            raise Exception("COULDNT BREAK {}".format(image_index))


        broken = plt.imread(output_path)
        print("ORIGINAL PREDICTION", predictimg(imageori, lenet))
        print("BROKEN PREDICTION", predictimg(broken, lenet))
        print("mse(broken, imageori)", mse(broken, imageori))
        print("mse(imagenew, imageori)", mse(imagenew, imageori))

        print("FINISHED {}".format(image_index))
        print()
def generate_pattern(modle, layer_name, filter_index, size=150):
	'''builds a loss func that maximizes the activation of the nth filter of the layer under consideration.'''
	layer_output = model.get_layer(layer_name).output
	loss = K.mean(layer_output[:, :, :, filter_index])
	grads = K.gradients(loss, model.input)[0]
	grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5)
	iterate = K.function([model.input], [loss, grads])
	input_img_data = np.random.random((1, size, size, 3)) * 20 + 128.
	step = 1
	for i in range(40):
		loss_value, grads_value = iterate([input_img_data])
		input_img_data += grads_value * step
	img = input_img_data[0]
	return deprocess_image(img)
def compile_gradient_function(input_model, category_index, layer_name):
    model = Sequential()
    model.add(input_model)

    num_classes = model.output_shape[1]
    target_layer = lambda x: target_category_loss(x, category_index, num_classes)
    model.add(Lambda(target_layer,
                     output_shape = target_category_loss_output_shape))

    loss = K.sum(model.layers[-1].output)
    conv_output = model.layers[0].get_layer(layer_name).output
    gradients = normalize(K.gradients(loss, conv_output)[0])
    gradient_function = K.function([model.layers[0].input, K.learning_phase()],
                                                    [conv_output, gradients])
    return gradient_function
Exemplo n.º 30
0
    def get_output(self, train=False):
        X = self.get_input(train)
        if self.dim_ordering == 'th':
            output = K.repeat_elements(X, self.size[0], axis=2)
            output = K.repeat_elements(output, self.size[1], axis=3)
        elif self.dim_ordering == 'tf':
            output = K.repeat_elements(X, self.size[0], axis=1)
            output = K.repeat_elements(output, self.size[1], axis=2)
        else:
            raise Exception('Invalid dim_ordering: ' + self.dim_ordering)

        f = K.gradients(K.sum(self._master_layer.get_output(train)),
                        self._master_layer.get_input(train)) * output

        return f
Exemplo n.º 31
0
import numpy as np
from keras import backend as K
from keras.applications import VGG16

model = VGG16(weights='imagenet', include_top=False)

layer_name = 'block3_conv1'
filter_index = 0

layer_output = model.get_layer(layer_name).output
loss = K.mean(layer_output[:, :, :, filter_index])
grads = K.gradients(loss, model.input)[0]

grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5)
iterate = K.function([model, input], [loss, grads])

loss_value, grads_value = iterate([np.zeros((1, 150, 150, 3))])

input_img_data = np.random.random((1, 150, 150, 3)) * 20 + 128.
step = 1.
for i in range(40):
    loss_value, grads_value = iterate([input_img_data])
    input_img_data += grads_value * step


def deprocess_image(x):
    x -= x.mean()
    x /= (x.std() + 1e-5)
    x *= 0.5
    x = np.clip(x, 0, 1)
Exemplo n.º 32
0
    def build_model(self):
        """Build a critic (value) network that maps (state, action) pairs -> Q-values."""
        # Define input layers
        states = layers.Input(shape=(self.state_size, ), name='states')
        actions = layers.Input(shape=(self.action_size, ), name='actions')

        # Add hidden layer(s) for state pathway
        net_states = layers.Dense(
            units=32,
            use_bias=False,
            kernel_regularizer=regularizers.l2(0.01),
            activity_regularizer=regularizers.l1(0.01))(states)
        net_states = layers.BatchNormalization()(net_states)
        net_states = layers.Activation('relu')(net_states)
        net_states = layers.Dropout(0.5)(net_states)

        net_states = layers.Dense(
            units=64,
            use_bias=False,
            kernel_regularizer=regularizers.l2(0.01),
            activity_regularizer=regularizers.l1(0.01))(states)
        net_states = layers.BatchNormalization()(net_states)
        net_states = layers.Activation('relu')(net_states)
        net_states = layers.Dropout(0.5)(net_states)

        net_states = layers.Dense(
            units=128,
            use_bias=False,
            kernel_regularizer=regularizers.l2(0.01),
            activity_regularizer=regularizers.l1(0.01))(states)
        net_states = layers.BatchNormalization()(net_states)
        net_states = layers.Activation('relu')(net_states)
        net_states = layers.Dropout(0.5)(net_states)

        # Add hidden layer(s) for action pathway
        net_actions = layers.Dense(
            units=32,
            use_bias=False,
            kernel_regularizer=regularizers.l2(0.01),
            activity_regularizer=regularizers.l1(0.01))(actions)
        net_actions = layers.BatchNormalization()(net_actions)
        net_actions = layers.Activation('relu')(net_actions)
        net_actions = layers.Dropout(0.5)(net_actions)

        net_actions = layers.Dense(
            units=64,
            use_bias=False,
            kernel_regularizer=regularizers.l2(0.01),
            activity_regularizer=regularizers.l1(0.01))(net_actions)
        net_actions = layers.BatchNormalization()(net_actions)
        net_actions = layers.Activation('relu')(net_actions)
        net_actions = layers.Dropout(0.5)(net_actions)

        net_actions = layers.Dense(
            units=128,
            use_bias=False,
            kernel_regularizer=regularizers.l2(0.01),
            activity_regularizer=regularizers.l1(0.01))(net_actions)
        net_actions = layers.BatchNormalization()(net_actions)
        net_actions = layers.Activation('relu')(net_actions)
        net_actions = layers.Dropout(0.5)(net_actions)

        # Try different layer sizes, activations, add batch normalization, regularizers, etc.

        # Combine state and action pathways
        net = layers.Add()([net_states, net_actions])
        net = layers.Activation('relu')(net)

        # Add more layers to the combined network if needed

        # Add final output layer to produce action values (Q values)
        Q_values = layers.Dense(units=1, name='q_values')(net)

        # Create Keras model
        self.model = models.Model(inputs=[states, actions], outputs=Q_values)

        # Define optimizer and compile model for training with built-in loss function
        optimizer = optimizers.Adam()
        self.model.compile(optimizer=optimizer, loss='mse')

        # Compute action gradients (derivative of Q values w.r.t. to actions)
        action_gradients = K.gradients(Q_values, actions)

        # Define an additional function to fetch action gradients (to be used by actor model)
        self.get_action_gradients = K.function(
            inputs=[*self.model.input, K.learning_phase()],
            outputs=action_gradients)
Exemplo n.º 33
0
            sampled_base_image_features = random_content_features[0]
            sampled_combination_image_features = random_content_features[1]

            loss += content_weight * radial_basis_content_loss(
                sampled_base_image_features,
                sampled_combination_image_features)

            print("Content Loss computed")

            loss += compute_nabla_loss(total_style_combination_features, loss,
                                       i)

            loss += total_variation_weight * total_variation_loss(
                Learner.combination_image)
            grads = K.gradients(loss, Learner.combination_image)

            outputs = [loss]

            if isinstance(grads, (list, tuple)):
                outputs += grads
            else:
                outputs.append(grads)

            f_outputs = K.function([Learner.combination_image], outputs)

            evaluator = Evaluator()

            final_loss = run_experiment(x)
            loss_tracker.append(final_loss)
Exemplo n.º 34
0
def _main(args):
    model_path = os.path.expanduser(args.model_path)
    assert model_path.endswith('.h5'), 'Keras model must be a .h5 file.'
    anchors_path = os.path.expanduser(args.anchors_path)
    classes_path = os.path.expanduser(args.classes_path)
    test_path = os.path.expanduser(args.test_path)
    output_path = os.path.expanduser(args.output_path)

    if not os.path.exists(output_path):
        print('Creating output path {}'.format(output_path))
        os.mkdir(output_path)

    sess = K.get_session()  # TODO: Remove dependence on Tensorflow session.

    with open(classes_path) as f:
        class_names = f.readlines()
    class_names = [c.strip() for c in class_names]

    with open(anchors_path) as f:
        anchors = f.readline()
        anchors = [float(x) for x in anchors.split(',')]
        anchors = np.array(anchors).reshape(-1, 2)

    yolo_model = load_model(model_path) # https://keras.io/models/model/

    # Verify model, anchors, and classes are compatible
    num_classes = len(class_names)
    num_anchors = len(anchors)
    # TODO: Assumes dim ordering is channel last
    model_output_channels = yolo_model.layers[-1].output_shape[-1]
    assert model_output_channels == num_anchors * (num_classes + 5), \
        'Mismatch between model and given anchor and class sizes. ' \
        'Specify matching anchors and classes with --anchors_path and ' \
        '--classes_path flags.'
    print('{} model, anchors, and classes loaded.'.format(model_path))

    # Check if model is fully convolutional, assuming channel last order.
    model_image_size = yolo_model.layers[0].input_shape[1:3]
    is_fixed_size = model_image_size != (None, None)

    # Generate colors for drawing bounding boxes.
    hsv_tuples = [(x / len(class_names), 1., 1.)
                  for x in range(len(class_names))]
    colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
    colors = list(
        map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
            colors))
    random.seed(10101)  # Fixed seed for consistent colors across runs.
    random.shuffle(colors)  # Shuffle colors to decorrelate adjacent classes.
    random.seed(None)  # Reset seed to default.

    # Generate output tensor targets for filtered bounding boxes.
    # TODO: Wrap these backend operations with Keras layers.
    yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
    input_image_shape = K.placeholder(shape=(2, ))

    # Get target scores for boxes, compute gradients
    boxes, scores, classes, target_scores = yolo_eval_adv(
        yolo_outputs,
        input_image_shape,
        score_threshold=args.score_threshold,
        iou_threshold=args.iou_threshold)
    correct_scores_loss = K.sum(scores)
    grad_correct, = K.gradients(correct_scores_loss, yolo_model.input)
    target_scores_loss = K.sum(target_scores)
    grad_target, = K.gradients(target_scores_loss, yolo_model.input)
    grad_sign = K.sign(grad_target)

    # target_boxes = np.array([[[0.5, 0.5, 0.25, 0.25, 0]], [[0.5, 0.5, 0.25, 0.25, 0]], [[0.5, 0.5, 0.25, 0.25, 0]], [[0.5, 0.5, 0.25, 0.25, 0]], [[0.5, 0.5, 0.25, 0.25, 0]]], dtype=np.float32)
    target_boxes = np.array([[[0.25, 0.25, 0.25, 0.25, 0]]], dtype=np.float32)
    detectors_mask, matching_true_boxes = get_detector_mask(target_boxes, anchors)
    args = (yolo_model.output, target_boxes, detectors_mask, matching_true_boxes)
    model_loss = yolo_loss(args, anchors, len(class_names))
    grad_mloss, = K.gradients(model_loss, yolo_model.input)

    for image_file in os.listdir(test_path):
        try:
            image_type = imghdr.what(os.path.join(test_path, image_file))
            if not image_type:
                continue
        except IsADirectoryError:
            continue

        image = Image.open(os.path.join(test_path, image_file))
        original_size = image.size
        if is_fixed_size:  # TODO: When resizing we can use minibatch input.
            resized_image = image.resize(
                tuple(reversed(model_image_size)), Image.BICUBIC)
            image_data = np.array(resized_image, dtype='float32')
        else:
            # Due to skip connection + max pooling in YOLO_v2, inputs must have
            # width and height as multiples of 32.
            new_image_size = (image.width - (image.width % 32),
                              image.height - (image.height % 32))
            resized_image = image.resize(new_image_size, Image.BICUBIC)
            image_data = np.array(resized_image, dtype='float32')
            print(image_data.shape)

        image_data /= 255.
        image_data = np.expand_dims(image_data, 0)  # Add batch dimension.
        image_data_adv = image_data.copy()

        print("Generating adversarial image")
        for i in range(100):
            print("Iteration " + str(i+1))
            mloss, g_mloss, = sess.run(
                [model_loss, grad_mloss],
                feed_dict={
                    yolo_model.input: image_data_adv,
                    input_image_shape: [image.size[1], image.size[0]],
                    K.learning_phase(): 0
                }
            )
            # Use sign instead of entire gradient
            # print(type(g_mloss))
            print(mloss)
            r = g_mloss
            gamma = 1e-1
            r = gamma * r
            # Gradient clipping?
            # image_data_adv = np.clip(image_data_adv + r, 0, image_data_adv)
            image_data_adv = image_data_adv - r

        '''
        print("Generating adversarial image")
        for i in range(30):
            print("Iteration " + str(i+1))
            g_correct, g_target, g_sign = sess.run(
                [grad_correct, grad_target, grad_sign],
                feed_dict={
                    yolo_model.input: image_data_adv,
                    input_image_shape: [image.size[1], image.size[0]],
                    K.learning_phase(): 0
                }
            )
            # Use sign instead of entire gradient
            r = g_sign
            gamma = 1e-5
            r = gamma * r

            # Only factor in gradient from target
            # r = g_target
            # gamma = 0.01
            # r = gamma * r / (np.max(np.abs(r)) + 1e-7)

            # Factor in correct and target gradient
            # gamma = 0.01
            # g_correct = g_correct / (np.max(np.abs(g_correct)) + 1e-7)
            # g_target = g_target / (np.max(np.abs(g_target)) + 1e-7)
            # r = g_target-g_correct
            # r = gamma * r / (np.max(np.abs(r)) + 1e-7)

            # Gradient clipping?
            image_data_adv = np.clip(image_data_adv + r, 0, image_data_adv*(1+gamma))
            # image_data_adv = image_data_adv / np.max(np.abs(image_data_adv)) # normalize
        '''
        # image_data_adv = image_data_adv / np.max(np.abs(image_data_adv)) # normalize
        image_adv = getImage(image_data_adv, original_size)

        print("Testing adversarial image")
        out_boxes, out_scores, out_classes = sess.run(
            [boxes, scores, classes],
            feed_dict={
                yolo_model.input: image_data_adv,
                input_image_shape: [image.size[1], image.size[0]],
                K.learning_phase(): 0
            })
        print('Found {} boxes for {}'.format(len(out_boxes), image_file))

        font = ImageFont.truetype(
            font='font/FiraMono-Medium.otf',
            size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))
        thickness = (image.size[0] + image.size[1]) // 300

        for i, c in reversed(list(enumerate(out_classes))):
            predicted_class = class_names[c]
            box = out_boxes[i]
            score = out_scores[i]

            label = '{} {:.2f}'.format(predicted_class, score)

            draw = ImageDraw.Draw(image_adv)
            label_size = draw.textsize(label, font)

            top, left, bottom, right = box
            top = max(0, np.floor(top + 0.5).astype('int32'))
            left = max(0, np.floor(left + 0.5).astype('int32'))
            bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
            right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
            print(label, (left, top), (right, bottom))

            if top - label_size[1] >= 0:
                text_origin = np.array([left, top - label_size[1]])
            else:
                text_origin = np.array([left, top + 1])

            # My kingdom for a good redistributable image drawing library.
            for i in range(thickness):
                draw.rectangle(
                    [left + i, top + i, right - i, bottom - i],
                    outline=colors[c])
            draw.rectangle(
                [tuple(text_origin), tuple(text_origin + label_size)],
                fill=colors[c])
            draw.text(text_origin, label, fill=(0, 0, 0), font=font)
            del draw

        image_adv.save(os.path.join(output_path, image_file), quality=90)
    sess.close()
Exemplo n.º 35
0
    def build_model(self):
        """Build a critic (value) network that maps (state, action) pairs -> Q-values."""
        # Define input layers
        # These two layers can first be processed via separate "pathways" (mini sub-networks), but eventually need to be combined.
        states = layers.Input(shape=(self.state_size, ), name='states')
        actions = layers.Input(shape=(self.action_size, ), name='actions')

        # Add hidden layer(s) for state pathway
        net_states = layers.Dense(
            units=400,
            activation='relu',
            kernel_regularizer=regularizers.l2(0.01))(states)
        # net_states = layers.Dense(units=400, kernel_regularizer=regularizers.l2(0.01))(states)
        # net_states = layers.BatchNormalization()(net_states)
        # net_states = layers.Activation('relu')(net_states)

        net_states = layers.Dense(
            units=300,
            activation='relu',
            kernel_regularizer=regularizers.l2(0.01))(net_states)
        # net_states = layers.Dense(units=300, kernel_regularizer=regularizers.l2(0.01))(net_states)
        # net_states = layers.BatchNormalization()(net_states)
        # net_states = layers.Activation('relu')(net_states)

        # Add hidden layer(s) for action pathway
        net_actions = layers.Dense(
            units=400,
            activation='relu',
            kernel_regularizer=regularizers.l2(0.01))(actions)
        net_actions = layers.Dense(
            units=300,
            activation='relu',
            kernel_regularizer=regularizers.l2(0.01))(net_actions)

        # Try different layer sizes, activations, add batch normalization, regularizers, etc.

        # Combine state and action pathways
        net = layers.Add()([net_states, net_actions])
        net = layers.Activation('relu')(net)

        # Add more layers to the combined network if needed
        net = layers.Dense(units=64,
                           activation='relu',
                           kernel_regularizer=regularizers.l2(0.01))(net)

        # Add final output layer to prduce action values (Q values)
        # The final output of this model is the Q-value for any given (state, action) pair.
        Q_values = layers.Dense(units=1, name='q_values')(net)

        # Create Keras model
        self.model = models.Model(inputs=[states, actions], outputs=Q_values)

        # Define optimizer and compile model for training with built-in loss function
        optimizer = optimizers.Adam(lr=0.001)
        self.model.compile(optimizer=optimizer, loss='mse')

        # Compute action gradients (derivative of Q values w.r.t. to actions)
        # Compute the gradient of this Q-value with respect to the corresponding action vector, needed for training the actor model.
        action_gradients = K.gradients(Q_values, actions)

        # Define an additional function to fetch action gradients (to be used by actor model)
        self.get_action_gradients = K.function(
            inputs=[*self.model.input, K.learning_phase()],
            outputs=action_gradients)
Exemplo n.º 36
0
def main():
    parser = argparse.ArgumentParser(
        prog='plot_saliency.py',
        description='ML-Assignment3 visualize attention heat map.')
    parser.add_argument('--epoch', type=int, metavar='<#epoch>', default=1)
    args = parser.parse_args()
    model_name = "modelok"
    model_path = os.path.join(model_dir, model_name)
    emotion_classifier = load_model(model_path)
    print(
        colored("Loaded model from {}".format(model_name),
                'yellow',
                attrs=['bold']))
    '''
    private_pixels = load_pickle('fer2013/test_with_ans_pixels.pkl')
    private_pixels = [ np.fromstring(private_pixels[i], dtype=float, sep=' ').reshape((1, 48, 48, 1)) 
                       for i in range(len(private_pixels)) ]
    '''
    private_pixels = load_np('valid_p.npy')
    input_img = emotion_classifier.input
    img_ids = [17]

    for idx in img_ids:
        val_proba = emotion_classifier.predict(
            np.expand_dims(private_pixels[idx], axis=0))
        pred = val_proba.argmax(axis=-1)
        print('pred=', pred)
        target = K.mean(emotion_classifier.output[:, pred])
        grads = K.gradients(target, input_img)[0]
        fn = K.function([input_img, K.learning_phase()], [grads])
        """
        Implement your heatmap processing here!
        hint: Do some normalization or smoothening on grads
        """

        heatmap = deprocessimage(grad)
        '''
        ===============
        '''
        thres = 0.5
        see = private_pixels[idx]
        # for i in range(48):
        # for j in range(48):
        # print heatmap[i][j]
        print('see=', type(see), 'heatmap=', type(heatmap), 'fn=', type(fn))
        see[np.where(np.array(heatmap) <= thres)] = np.mean(see)

        plt.figure()
        plt.imshow(heatmap, cmap=plt.cm.jet)
        plt.colorbar()
        plt.tight_layout()
        fig = plt.gcf()
        plt.draw()
        test_dir = os.path.join(cmap_dir, 'test')
        if not os.path.exists(test_dir):
            os.makedirs(test_dir)
        fig.savefig(os.path.join(test_dir, '{}.png'.format(idx)), dpi=100)

        plt.figure()
        plt.imshow(see, cmap='gray')
        plt.colorbar()
        plt.tight_layout()
        fig = plt.gcf()
        plt.draw()
        test_dir = os.path.join(partial_see_dir, 'test')
        if not os.path.exists(test_dir):
            os.makedirs(test_dir)
        fig.savefig(os.path.join(test_dir, '{}.png'.format(idx)), dpi=100)
Exemplo n.º 37
0
#y = K.variable(value = Y_train)
#label = K.variable(value = L_train)

W = K.variable(value=1.)  #np.random.rand(1))
b = K.variable(value=-1.)  #np.random.rand(1))
U = K.square(W * x + b)

lamda = K.variable(value=1.)  #np.random.rand(1))
U2 = y - lamda * U

U2 = K.tanh(U2)

loss = K.square(U2 - label)
loss = K.mean(loss)

grad = K.gradients(loss, [W, b, lamda])

#--------------------uniformize gradient
sum_grad = 0
for i in range(len(grad)):
    sum_grad += K.square(grad[i])

for i in range(len(grad)):
    grad[i] /= (K.sqrt(sum_grad) + 1e-5)

#--------using sgd with momentum
momentum = 0.7
for i in range(len(grad)):
    grad[i] = grad_t[i] * momentum + grad[i]

step = K.variable(value=0.05)
Exemplo n.º 38
0
    content_feat = image_features[layer][CONTENT, :, :, :]
    target_feat = image_features[layer][TARGET, :, :, :]
    loss += content_weight * content_loss(content_feat, target_feat)

nb_layers = len(style_feature_layers)

for i, layer in enumerate(style_feature_layers):
    style_feat = image_features[layer][STYLE, :, :, :]
    target_feat = image_features[layer][TARGET, :, :, :]
    style_masks = mask_features[layer][STYLE, :, :, :]
    target_masks = mask_features[layer][TARGET, :, :, :]
    sl = style_loss(style_feat, target_feat, style_masks, target_masks)
    loss += (style_weight / (2**(nb_layers - (i + 1)))) * sl

loss += total_variation_weight * total_variation_loss(target_image)
loss_grads = K.gradients(loss, target_image)

# Evaluator class for computing efficiency
outputs = [loss]
if type(loss_grads) in {list, tuple}:
    outputs += loss_grads
else:
    outputs.append(loss_grads)

f_outputs = K.function([target_image], outputs)


def eval_loss_and_grads(x):
    if K.image_dim_ordering() == 'th':
        x = x.reshape((1, 3, img_nrows, img_ncols))
    else:
Exemplo n.º 39
0
	#convolutional layer as the input instead of a fully-conected

layer_output = layer_dict[layer_name].output
#layer_output = model.layers[0].output
for n in range(1,32):
	filter_index = n
	print('Processing filter %d' % filter_index)
	start_time = time.time()
	#build a loss function that maximizes the activation of n filters of the layer considered

	#TODO: select one of these loss function depending on which layer you're using
	#loss = backend.mean(layer_output[:, filter_index]) # loss function for dense layers
	loss = backend.mean(layer_output[:,filter_index,:,:]) # for non-dense layers

	#compute gradient of input picture wrt this loss
	grads = backend.gradients(loss, input_img)[0]
	#normalize gradient to avoid values
	grads /= (backend.sqrt(backend.mean(backend.square(grads))) + 1e-5)

	#this function returns loss and grads given the input picture
	iterate = backend.function([input_img, backend.learning_phase()],[loss,grads])

	#set numpy's random seed for reproducibility
	numpy.random.seed(117)

	#start with random grayscale image to begin gradient ascent on
	input_img_data = numpy.random.random((1,1,img_width, img_height))*20+128

	#run gradient ascent on current filter for x steps until loss function is maximized
	for i in range(1000):
		#compute loss and gradients
Exemplo n.º 40
0
def _learner_thread(thread_id, session_global, graph_ops):
    logger = logging.getLogger("learner")
    logger.info("STARTING THREAD:%d" % thread_id)

    # params tensors
    actor_params = graph_ops["actor_params"]
    critic_params = graph_ops["critic_params"]

    env = AntTurnEnv({
        'server_ip': '127.0.0.1',
        'server_port': VREP_PORT + thread_id,
        'vrep_exec_path': None,
        'vrep_scene_file': None,
        'per_step_reward': PER_STEP_REWARD,
        'final_reward': FINAL_REWARD,
        'tolerance': TOLERANCE,
        'spawn_radius': SPAWN_RADIUS
    })

    gamma = 0.99
    with tf.Graph().as_default(), tf.Session() as session:
        # make local networks
        lstate = tf.placeholder(tf.float32, [None, STATE_SIZE])
        lgoal = tf.placeholder(tf.float32, [None, GOAL_SIZE])
        laction = tf.placeholder(tf.float32, [None, ACTION_SIZE])

        lactor, lact_grad, lactor_grads = create_actor_with_goal(
            STATE_SIZE, GOAL_SIZE, ACTION_SIZE)
        lcritic, l_action_grads = create_critic_with_goal(
            STATE_SIZE, GOAL_SIZE, ACTION_SIZE)

        # basics
        lq_values = lcritic([lstate, lgoal, laction])
        lactor_action = lactor([lstate, lgoal])

        # obtain critic grad_Q_wrt_a
        l_grad_Q_wrt_a = K.function(
            inputs=[lcritic.inputs[0], lcritic.inputs[1], lcritic.inputs[2]],
            outputs=l_action_grads)
        # obtain full actor grads
        l_actor_full_grads = K.function(
            inputs=[lactor.inputs[0], lactor.inputs[1], lact_grad],
            outputs=lactor_grads)

        # obtain full critic gradients
        target_qs = tf.placeholder(tf.float32, [None, 1])
        critic_loss = tf.reduce_sum(tf.square(target_qs - lq_values))
        critic_grads = K.gradients(critic_loss, lcritic.trainable_weights)
        l_critic_full_grads = K.function(
            inputs=[lstate, lgoal, laction, target_qs], outputs=critic_grads)

        lactor_params = lactor.trainable_weights
        lcritic_params = lcritic.trainable_weights
        lactor_set_params = lambda x: [
            lactor_params[i].assign(x[i]) for i in range(len(x))
        ]
        lcritic_set_params = lambda x: [
            lcritic_params[i].assign(x[i]) for i in range(len(x))
        ]

        session.run(tf.global_variables_initializer())

        logger.info("Obtaining target network params")
        local_params = [session_global.run(param) for param in actor_params]
        lactor_set_params(local_params)
        local_params = [session_global.run(param) for param in critic_params]
        lcritic_set_params(local_params)
        num_goals_achieved = 0

        for epoch in range(0, NUM_EPOCHS):
            cur_states = np.zeros((0, STATE_SIZE))
            cur_goals = np.zeros((0, GOAL_SIZE))
            next_states = np.zeros((0, STATE_SIZE))
            next_goals = np.zeros((0, GOAL_SIZE))
            actions = np.zeros((0, ACTION_SIZE))
            rewards = np.zeros((0, 1))
            non_terminal = np.zeros((0, 1))
            episode = 0

            for episode in range(0, NUM_EPISODES_PER_EPOCH):
                # cur_goal = randomly generated starting goal
                rand_goal = np.random.uniform(-np.pi / 12.0, +np.pi / 12.0)
                env.set_goal(rand_goal)
                cur_state, cur_goal = env.start()
                thread_goals[thread_id, epoch, episode] = cur_goal
                next_state, next_goal = cur_state, cur_goal
                num_steps = 0
                total_reward = 0

                logger.info("START:epoch:%d, episode:%d, goal:%f" %
                            (epoch, episode, cur_goal))
                # V-REP streaming should now be ready
                for step_no in range(0, MAX_EPISODE_LEN):
                    action = session.run(lactor_action,
                                         feed_dict={
                                             lstate: cur_state,
                                             lgoal: cur_goal
                                         })[0].reshape((1, -1))
                    # NOTE : adding a small random noise to system
                    action += np.random.normal(loc=0.0,
                                               scale=0.05,
                                               size=action.shape)
                    next_state, next_goal, reward, has_ended = env.step(
                        np.hstack((action.reshape((-1, )), np.zeros(5))))
                    cur_states = np.vstack((cur_states, cur_state))
                    next_states = np.vstack((next_states, next_state))
                    cur_goals = np.vstack((cur_goals, cur_goal))
                    next_goals = np.vstack((next_goals, next_goal))
                    rewards = np.vstack((rewards, reward))
                    if has_ended:
                        non_terminal = np.vstack((non_terminal, 0.0))
                        num_goals_achieved += 1
                    else:
                        non_terminal = np.vstack((non_terminal, 1.0))
                    actions = np.vstack((actions, action))

                    total_reward += reward
                    num_steps += 1
                    if has_ended:
                        logger.info("achieved goal")
                        break
                    cur_state = next_state
                    cur_goal = next_goal
                env.reset()
                thread_num_steps[thread_id, epoch, episode] = num_steps
                thread_episodic_reward[thread_id, epoch,
                                       episode] = total_reward
                logger.info("END:epoch:%d, episode:%d, goal:%f, num_steps:%d" %
                            (epoch, episode, rand_goal, num_steps))

            logger.info("preparing updates")
            for update_no in range(0, NUM_UPDATES_PER_EPOCH):
                # obtain critic q-values
                logger.info("update:%d" % update_no)
                q_values = session.run(lq_values,
                                       feed_dict={
                                           lstate: next_states,
                                           lgoal: next_goals,
                                           laction: actions
                                       }).reshape((-1, 1))
                # obtain targets for critic
                targets = rewards + gamma * np.multiply(
                    non_terminal, q_values).reshape((-1, 1))

                # compute full actor and critic grads
                # actor update
                # logger.info("ACTOR update")
                local_action_grads = l_grad_Q_wrt_a(
                    [cur_states, cur_goals, actions])[0]
                full_local_actor_grads = l_actor_full_grads(
                    [cur_states, cur_goals, local_action_grads])
                graph_ops["actor_grad_copy"](full_local_actor_grads)
                session_global.run(graph_ops["actor_grad_apply"])

                # critic update
                # logger.info("CRITIC update")
                full_local_critic_grads = l_critic_full_grads(
                    [cur_states, cur_goals, actions, targets])
                graph_ops["critic_grad_copy"](full_local_critic_grads)
                session_global.run(graph_ops["critic_grad_apply"])

                # update params from server
                logger.info("RESET TARGET NETWORK PARAMS")
                local_params = [
                    session_global.run(param) for param in actor_params
                ]
                lactor_set_params(local_params)
                local_params = [
                    session_global.run(param) for param in critic_params
                ]
                lcritic_set_params(local_params)

            # compute losses for summary
            thread_critic_loss[thread_id, epoch] = session.run(critic_loss,
                                                               feed_dict={
                                                                   lstate:
                                                                   cur_states,
                                                                   lgoal:
                                                                   cur_goals,
                                                                   laction:
                                                                   actions,
                                                                   target_qs:
                                                                   targets
                                                               })
            thread_goals_achieved[thread_id,
                                  epoch] = 100 * num_goals_achieved * 1.0 / (
                                      (epoch + 1) * NUM_EPISODES_PER_EPOCH *
                                      1.0)

            # if out of sync, re-sync target networks with server
            if np.mod(epoch, RESET_TARGET_NETWORK_EPOCHS) == 0:
                logger.info("RESET TARGET NETWORK PARAMS")
                local_params = [
                    session_global.run(param) for param in actor_params
                ]
                lactor_set_params(local_params)
                local_params = [
                    session_global.run(param) for param in critic_params
                ]
                lcritic_set_params(local_params)

    logger.info("EXITING THREAD:%d" % thread_id)
Exemplo n.º 41
0
    # plt.show()

    # make a content model
    # try different cutoffs to see the images that result
    content_model = VGG16_AvgPool_CutOff(shape, 11)

    # make the target
    target = K.variable(content_model.predict(x))

    # try to match the image

    # define our loss in keras
    loss = K.mean(K.square(target - content_model.output))

    # gradients which are needed by the optimizer
    grads = K.gradients(loss, content_model.input)

    # just like theano.function
    get_loss_and_grads = K.function(inputs=[content_model.input],
                                    outputs=[loss] + grads)

    def get_loss_and_grads_wrapper(x_vec):
        # scipy's minimizer allows us to pass back
        # function value f(x) and its gradient f'(x)
        # simultaneously, rather than using the fprime arg
        #
        # we cannot use get_loss_and_grads() directly
        # input to minimizer func must be a 1-D array
        # input to get_loss_and_grads must be [batch_of_images]
        #
        # gradient must also be a 1-D array
Exemplo n.º 42
0
def dream(base_image_path, result_prefix, feature_number, mixed_layers):

    # These are the names of the layers
    # for which we try to maximize activation,
    # as well as their weight in the final loss
    # we try to maximize.
    # You can tweak these setting to obtain new visual effects.
    settings = {
        'features': {
            #        'mixed0': 1,
            #         'mixed3': 0.5,
            #        'mixed4': 2.,
            #        'mixed5': 1.5,
        },
    }

    for ml in mixed_layers:
        settings['features'][ml] = 1

    def preprocess_image(image_path):
        # Util function to open, resize and format pictures
        # into appropriate tensors.
        img = plt.imread(image_path)
        img = img_to_array(img)
        img = np.expand_dims(img, axis=0)
        img = inception_v3.preprocess_input(img)
        return img

    def deprocess_image(x):
        # Util function to convert a tensor into a valid image.
        if K.image_data_format() == 'channels_first':
            x = x.reshape((3, x.shape[2], x.shape[3]))
            x = x.transpose((1, 2, 0))
        else:
            x = x.reshape((x.shape[1], x.shape[2], 3))
        x /= 2.
        x += 0.5
        x *= 255.
        x = np.clip(x, 0, 255).astype('uint8')
        return x

    K.set_learning_phase(0)

    # Build the InceptionV3 network with our placeholder.
    # The model will be loaded with pre-trained ImageNet weights.
    model = inception_v3.InceptionV3(weights='imagenet', include_top=False)
    dream = model.input
    print('Model loaded.')

    # Get the symbolic outputs of each "key" layer (we gave them unique names).
    layer_dict = dict([(layer.name, layer) for layer in model.layers])

    # Define the loss.
    loss = K.variable(0.)
    for layer_name in settings['features']:
        # Add the L2 norm of the features of a layer to the loss.
        assert layer_name in layer_dict.keys(
        ), 'Layer ' + layer_name + ' not found in model.'
        coeff = settings['features'][layer_name]
        x = layer_dict[layer_name].output
        # We avoid border artifacts by only involving non-border pixels in the loss.
        scaling = K.prod(K.cast(K.shape(x), 'float32'))
        if K.image_data_format() == 'channels_first':
            loss += coeff * K.sum(K.square(x[:, feature_number, 2:-2,
                                             2:-2])) / scaling
        else:
            loss += coeff * K.sum(K.square(x[:, 2:-2, 2:-2,
                                             feature_number])) / scaling

    # Compute the gradients of the dream wrt the loss.
    grads = K.gradients(loss, dream)[0]
    # Normalize gradients.
    grads /= K.maximum(K.mean(K.abs(grads)), K.epsilon())

    # Set up function to retrieve the value
    # of the loss and gradients given an input image.
    outputs = [loss, grads]
    fetch_loss_and_grads = K.function([dream], outputs)

    def eval_loss_and_grads(x):
        outs = fetch_loss_and_grads([x])
        loss_value = outs[0]
        grad_values = outs[1]
        return loss_value, grad_values

    def resize_img(img, size):
        img = np.copy(img)
        if K.image_data_format() == 'channels_first':
            factors = (1, 1, float(size[0]) / img.shape[2],
                       float(size[1]) / img.shape[3])
        else:
            factors = (1, float(size[0]) / img.shape[1],
                       float(size[1]) / img.shape[2], 1)
        return scipy.ndimage.zoom(img, factors, order=1)

    def gradient_ascent(x, iterations, step, max_loss=None):
        for i in range(iterations):
            loss_value, grad_values = eval_loss_and_grads(x)
            if max_loss is not None and loss_value > max_loss:
                break
            print('..Loss value at', i, ':', loss_value)
            x += step * grad_values
        return x

    def save_img(img, fname):
        pil_img = deprocess_image(np.copy(img))
        scipy.misc.imsave(fname, pil_img)

    """Process:
    - Load the original image.
    - Define a number of processing scales (i.e. image shapes),
        from smallest to largest.
    - Resize the original image to the smallest scale.
    - For every scale, starting with the smallest (i.e. current one):
        - Run gradient ascent
        - Upscale image to the next scale
        - Reinject the detail that was lost at upscaling time
    - Stop when we are back to the original size.
    To obtain the detail lost during upscaling, we simply
    take the original image, shrink it down, upscale it,
    and compare the result to the (resized) original image.
    """

    # Playing with these hyperparameters will also allow you to achieve new effects
    step = 0.01  # Gradient ascent step size
    num_octave = 3  # Number of scales at which to run gradient ascent
    octave_scale = 1.4  # Size ratio between scales
    iterations = 20  # Number of ascent steps per scale
    max_loss = 10.

    #Original:
    #    # Playing with these hyperparameters will also allow you to achieve new effects
    #    step = 0.01  # Gradient ascent step size
    #    num_octave = 3  # Number of scales at which to run gradient ascent
    #    octave_scale = 1.4  # Size ratio between scales
    #    iterations = 20  # Number of ascent steps per scale
    #    max_loss = 10.

    img = preprocess_image(base_image_path)
    if K.image_data_format() == 'channels_first':
        original_shape = img.shape[2:]
    else:
        original_shape = img.shape[1:3]
    successive_shapes = [original_shape]
    for i in range(1, num_octave):
        shape = tuple([int(dim / (octave_scale**i)) for dim in original_shape])
        successive_shapes.append(shape)
    successive_shapes = successive_shapes[::-1]
    original_img = np.copy(img)
    shrunk_original_img = resize_img(img, successive_shapes[0])

    for shape in successive_shapes:
        print('Processing image shape', shape)
        img = resize_img(img, shape)
        img = gradient_ascent(img,
                              iterations=iterations,
                              step=step,
                              max_loss=max_loss)
        upscaled_shrunk_original_img = resize_img(shrunk_original_img, shape)
        same_size_original = resize_img(original_img, shape)
        lost_detail = same_size_original - upscaled_shrunk_original_img

        img += lost_detail
        shrunk_original_img = resize_img(original_img, shape)

    save_img(img,
             fname=result_prefix + "fn_" + str(feature_number) + "_" +
             mixed_layers[0] + "_" + os.path.basename(base_image_path))
Exemplo n.º 43
0
    style_features = layer_features[1, :, :, :]
    combination_features = layer_features[2, :, :, :]
    sl = style_loss(style_features, combination_features)
    loss += ((style_weight / len(feature_layers)) * sl)
    
def total_variation_loss(x):
    a = backend.square(x[:, :height-1, :width-1, :] - x[:, 1:, :width-1, :])
    b = backend.square(x[:, :height-1, :width-1, :] - x[:, :height-1, 1:, :])
    return backend.sum(backend.pow(a + b, 1.25))

loss+=( total_variation_weight * total_variation_loss(combination_image))




grads = backend.gradients(loss, combination_image)

outputs = [loss]
outputs += grads
f_outputs = backend.function([combination_image], outputs)

def eval_loss_and_grads(x):
    x = x.reshape((1, height, width, 3))
    outs = f_outputs([x])
    loss_value = outs[0]
    grad_values = outs[1].flatten().astype('float64')
    return loss_value, grad_values

class Evaluator(object):

    def __init__(self):
Exemplo n.º 44
0
loss = K.variable(0.)
layer_features = outputs_dict[content_layer]
target_image_features = layer_features[0, :, :, :]
combination_features = layer_features[2, :, :, :]
loss += content_weight * content_loss(target_image_features,
                                      combination_features)
for layer_name in style_layers:
    layer_features = outputs_dict[layer_name]
    style_reference_features = layer_features[1, :, :, :]
    combination_features = layer_features[2, :, :, :]
    sl = style_loss(style_reference_features, combination_features)
    loss += (style_weight / len(style_layers)) * sl
loss += total_variation_weight * total_variation_loss(combination_image)

# Get the gradients of the generated image wrt the loss
grads = K.gradients(loss, combination_image)[0]

# Function to fetch the values of the current loss and the current gradients
fetch_loss_and_grads = K.function([combination_image], [loss, grads])


class Evaluator(object):
    def __init__(self):
        self.loss_value = None
        self.grads_values = None

    def loss(self, x):
        assert self.loss_value is None
        x = x.reshape((1, img_height, img_width, 3))
        outs = fetch_loss_and_grads([x])
        loss_value = outs[0]
Exemplo n.º 45
0
    def synTexture(self, im=None, G0_from=None,onlyGram=False,maxiter=500):
        model = self.model
        use_caffe = self.use_caffe
        conv_layers = [0,1,3,4,6,7,8,9,11,12,13,14,16,17,18,19]
        mm=np.array([ 0.40760392,  0.45795686,  0.48501961])
        if im is not None:
            im0=im

            if not use_caffe:
                im[:,:,0] -= 103.939
                im[:,:,1] -= 116.779
                im[:,:,2] -= 123.68
            else: # caffe
                im = im/255.0

                im[:,:,0]=im[:,:,0]-np.mean(im[:,:,0])+mm[0] # b
                im[:,:,1]=im[:,:,1]-np.mean(im[:,:,1])+mm[1] # g
                im[:,:,2]=im[:,:,2]-np.mean(im[:,:,2])+mm[2] # r


            #im = im.transpose((2,0,1))
            im = np.expand_dims(im, axis=0)
            # Test pretrained model

            #model = VGG_19_1('dataout.h5',onlyconv=True)
            #vgg19_weights.h5
            #sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
            #model.compile(optimizer=sgd, loss='categorical_crossentropy')
            print 'predicting'
            out = model.predict(im)

            #conv_layers = [1,3,6,8,11,13,15,17,20,22,24,26,29,31,33,35]

            activations = get_activations(model,im,conv_layers)

            G0, F0 = get_gram_matrices(activations)
        elif G0_from is not None:
            G0 = pickle.load(open(G0_from,'r'))
            print 'using saved G0 file (probably compressed)'


        #G0 = compress_gram(G0)

        if onlyGram:
            return G0, F0

        G0_symb, N_l, M_l = get_gram_matrices_symb(model,sel=conv_layers)

        errf = get_gram_error(G0,G0_symb,N_l,M_l)
        #print errf
        grads = K.gradients(errf,model.input)
        #opt = Adam()

        #opt.get_gradients
        #updates = opt.get_updates([model.input],[],[errf])
        #train = K.function([model.input],[errf, model.input],updates=updates)
        coef=0.5 if use_caffe else 128.0
        gray_im = np.random.randn(224,224)
        im_iter = np.stack([gray_im,gray_im,gray_im],axis=2)*coef
        #im_iter = np.random.randn(im0.shape[0],im0.shape[1],im0.shape[2])*coef
        for i in range(3):
            if use_caffe:
                im_iter[:,:,i]=im_iter[:,:,i]+mm[i]
            else:
                im_iter[:,:,i]=im_iter[:,:,i]+0*128.0


        iters = 10000
        plt.figure()
        _,pp=plt.subplots(2,2)
        costs=[]
        grads_fun = K.function([model.input],grads)
        cost_fun = K.function([model.input],[errf])

        """
        x = Input(batch_shape=(1,224,224,3))
        #opt_model = Model(inputs=x,outputs=G0_symb)
        class CustomLossLayer(Layer):
            def __init__(self, **kwargs):
                self.is_placeholder = True
                super(CustomLossLayer, self).__init__(**kwargs)

            def call(self, inputs):
                loss = get_gram_error(G0,inputs,N_l,M_l)
                self.add_loss(loss, inputs=inputs)
                return inputs

        y = CustomLossLayer()(G0_symb) # G0_symb is a list
        print y

        opt_model = Model([model.input], y)
        rmsprop = RMSprop()
        opt_model.compile(optimizer='rmsprop', loss=None)
        epochs=100
        opt_model.fit([im_iter],
            shuffle=True,
            epochs=epochs,
            verbose=2,
            batch_size=1)

        res =  opt_model.predict(im_iter)
        plt.imshow(im_iter)
        plt.show(block=False)
        plt.pause(0.01)
        """
        #"""
        if use_caffe:
            ranges = [-1,4]
            limits = [0.0,1.0]
        else:
            ranges = [-8,-3]
            limits =[-255, 255.0]
        def limit_im(im):
            im[im<limits[0]]=limits[0]
            im[im>limits[1]]=limits[1]
            return im
        def best_stepsize(im0, grad, steps=np.logspace(ranges[0],ranges[1],15)):
            best = -1
            best_loss = np.inf
            for s in steps:
                new_im = limit_im(im0-s*grad)
                #loss = cost_fun([np.expand_dims(im0-s*grad,0)])[0]
                loss = cost_fun([np.expand_dims(new_im,0)])[0]
                #print loss
                if loss<best_loss:
                    best = s
                    best_loss = loss
            return best

        # bfgs?
        imsize = [224,224,3]
        #maxiter = 2000
        method = 'L-BFGS-B'
        #method = 'BFGS'
        global cur_iter
        cur_iter=0
        global stats_im
        stats_im = []
        global res_im
        res_im = []
        def callback(x):
            global cur_iter
            global stats_im
            global res_im
            #print 'random number',np.random.rand(1)
            if not cur_iter%15:
                im = np.reshape(x,imsize)[:,:,::-1]
                im = np.sum(im,axis=2)/3.0 # turn to grayscale
                plt.imshow(im,cmap=plt.cm.gray)
                plt.imsave('res/syn_res.png',im,cmap=plt.cm.gray)
                if cur_iter==225:
                    plt.imsave('res/exp_%d_res_%d.png'%(self.exp_no,cur_iter),im,cmap=plt.cm.gray)
                    # saveing all stats
                    stats_im = get_stats(im)
                    stats_src, stats_tar = self.stats
                    res_im = im
                    with open('res/exp_%d_stats.txt'%self.exp_no,'w') as f:
                        f.write('stats src')
                        f.write(str(stats_src))
                        f.write('\nstats tar')
                        f.write(str(stats_tar))
                        f.write('\nstats syn')
                        f.write(str(stats_im))
                    print 'SAVED STATS'
                plt.title('iter %d'%cur_iter)
            cur_iter+=1
            plt.show(block=False)
            plt.pause(0.01)
        m=20
        reshape_im = lambda x: np.reshape(x, imsize)
        bounds = (np.ones_like(im_iter)*limits[0],np.ones_like(im_iter)*limits[1])
        bounds = zip(bounds[0].flatten(),bounds[1].flatten())
        min_fun = lambda x: cost_fun([np.expand_dims(reshape_im(x),0)])[0].astype(np.float64)
        grad_fun = lambda x: np.squeeze(grads_fun([np.expand_dims(reshape_im(x),0)])[0]).flatten().astype(np.float64)
        try:
            res = minimize(min_fun,im_iter.flatten().astype(np.float64),
                       jac=grad_fun,method=method,bounds=bounds,callback=callback,
                       options={'disp': False, 'maxiter':maxiter,
                                'maxcor': m, 'ftol': 0, 'gtol': 0})
        except:
            pass
        stats_src, stats_tar = self.stats
        return stats_src, stats_tar, stats_im, res_im
        #pp[0,0].imshow(im_iter)
        #pp[0,1].imshow(res[::-1])
        #plt.show(block=False)
        #plt.pause(0.01)
        #raw_input('done')
        #"""
        """
Exemplo n.º 46
0
layer_dict = dict([(layer.name, layer) for layer in model.layers])
input_img = layer_dict["embedding_1"].output

num_filters = layer_dict[layer_name].output.shape[2]

filters = []
for filter_index in range(num_filters):
    start_time = time.time()

    # We build a loss function that maximizes the activation
    # of the nth filter of the layer considered
    layer_output = layer_dict[layer_name].output
    loss = K.mean(layer_output[:, :, filter_index])

    grads = K.gradients(loss, input_img)[0]
    grads = normalize(grads)

    iterate = K.function([input_img], [loss, grads])

    step = 0.3

    input_img_data = np.random.random((1, img_width, img_height))
    input_img_data = (input_img_data - 0.5) * 50 + 128

    # Run gradient ascent
    for i in range(30):
        loss_value, grads_value = iterate([input_img_data])
        input_img_data += grads_value * step

        if loss_value <= 0.:
Exemplo n.º 47
0
 def call(self, x, **kwargs):
     return K.gradients(self.y, x)[0]
    def _generate_filter_image(input_img,
                               layer_output,
                               filter_index):
        """Generates image for one particular filter.

        # Arguments
            input_img: The input-image Tensor.
            layer_output: The output-image Tensor.
            filter_index: The to be processed filter number.
                          Assumed to be valid.

        #Returns
            Either None if no image could be generated.
            or a tuple of the image (array) itself and the last loss.
        """
        s_time = time.time()

        # we build a loss function that maximizes the activation
        # of the nth filter of the layer considered
        if K.image_data_format() == 'channels_first':
            loss = K.mean(layer_output[:, filter_index, :, :])
        else:
            loss = K.mean(layer_output[:, :, :, filter_index])

        # we compute the gradient of the input picture wrt this loss
        grads = K.gradients(loss, input_img)[0]

        # normalization trick: we normalize the gradient
        grads = normalize(grads)

        # this function returns the loss and grads given the input picture
        iterate = K.function([input_img], [loss, grads])

        # we start from a gray image with some random noise
        intermediate_dim = tuple(
            int(x / (upscaling_factor ** upscaling_steps)) for x in output_dim)
        if K.image_data_format() == 'channels_first':
            input_img_data = np.random.random(
                (1, 3, intermediate_dim[0], intermediate_dim[1]))
        else:
            input_img_data = np.random.random(
                (1, intermediate_dim[0], intermediate_dim[1], 3))
        input_img_data = (input_img_data - 0.5) * 20 + 128

        # Slowly upscaling towards the original size prevents
        # a dominating high-frequency of the to visualized structure
        # as it would occur if we directly compute the 412d-image.
        # Behaves as a better starting point for each following dimension
        # and therefore avoids poor local minima
        for up in reversed(range(upscaling_steps)):
            # we run gradient ascent for e.g. 20 steps
            for _ in range(epochs):
                loss_value, grads_value = iterate([input_img_data])
                input_img_data += grads_value * step

                # some filters get stuck to 0, we can skip them
                if loss_value <= K.epsilon():
                    return None

            # Calculate upscaled dimension
            intermediate_dim = tuple(
                int(x / (upscaling_factor ** up)) for x in output_dim)
            # Upscale
            img = deprocess_image(input_img_data[0])
            img = np.array(pil_image.fromarray(img).resize(intermediate_dim,
                                                           pil_image.BICUBIC))
            input_img_data = np.expand_dims(
                process_image(img, input_img_data[0]), 0)

        # decode the resulting input image
        img = deprocess_image(input_img_data[0])
        e_time = time.time()
        print('Costs of filter {:3}: {:5.0f} ( {:4.2f}s )'.format(filter_index,
                                                                  loss_value,
                                                                  e_time - s_time))
        return img, loss_value
Exemplo n.º 49
0
def hackAutoEncode():
    raw_images = getDataFromMnist()
    generator_images = np.copy(raw_images)
    # image = get_images(generator_images)
    # image = (image / 2.0 + 0.5) * 255.0
    # Image.fromarray(image.astype(np.uint8)).save('./hackAutoEncode/100mnist-raw.png')
    # image = 255.0 - image
    # Image.fromarray(image.astype(np.uint8)).save('./hackAutoEncode/100mnist-raw-w.png')

    # 将获取的图片reshape成想要的形状
    generator_images = generator_images.reshape((100, 784))

    # 获取模型
    model = trainAutoEncode()

    # 都伪装成0
    object_type_to_fake = getZeroFromMnist()  # 获取标签为0的图片
    object_type_to_fake = object_type_to_fake.reshape((28 * 28, ))
    object_type_to_fake = np.expand_dims(object_type_to_fake, axis=0)

    model_input_layer = model.layers[0].input
    model_output_layer = model.layers[-1].output

    # 生成的图像与图案0之间的差为损失函数 下面的三种损失函数都可以用
    # cost_function = binary_crossentropy(y_pred,object_type_to_fake)
    cost_function = K.mean(K.square(model_output_layer-object_type_to_fake))
    # cost_function = K.mean(K.binary_crossentropy(model_output_layer, object_type_to_fake))

    gradient_function = K.gradients(cost_function, model_input_layer)[0]
    grab_cost_and_gradients_from_model = K.function([model_input_layer, K.learning_phase()],
                                                    [cost_function, gradient_function])
    cost = 0.0
    e = 0.007
    for index in range(100):
        mnist_image_raw = generator_images[index]
        mnist_image_hacked = np.copy(mnist_image_raw)
        mnist_image_hacked = mnist_image_hacked.reshape(28*28, )
        mnist_image_hacked = np.expand_dims(mnist_image_hacked, axis=0)

        # 调整的极限 灰度图片
        max_change_above = mnist_image_raw + 1.0
        max_change_below = mnist_image_raw - 1.0

        i = 0
        cost = 100
        while cost > -12.0 and i < 500:
            cost, gradients = grab_cost_and_gradients_from_model([mnist_image_hacked, 0])

            n = np.sign(gradients)
            mnist_image_hacked -= n * e

            mnist_image_hacked = np.clip(mnist_image_hacked, max_change_below, max_change_above)
            mnist_image_hacked = np.clip(mnist_image_hacked, -1.0, 1.0)

            print("image_seg: {}, batch:{} Cost: {:.8}%".format(index, i, cost * 100))
            i += 1

        # 覆盖原有图片
        generator_images[index] = mnist_image_hacked

    autoEncode_images = np.copy(generator_images)
    generator_images = generator_images.reshape(100, 28, 28, 1)

    # 保存图片
    image = get_images(generator_images)
    image = (image/2.0+0.5)*255.0
    Image.fromarray(image.astype(np.uint8)).save("./hackAutoEncode/100mnist-hacked.png")

    # image=255.0-image
    # Image.fromarray(image.astype(np.uint8)).save("hackAutoEncode/100mnist-hacked-w.png")

    # 灰度图像里面黑是0 白是255 可以把中间状态的处理下
    # image[image>127]=255
    # Image.fromarray(image.astype(np.uint8)).save("hackAutoEncode/100mnist-hacked-w-good.png")

    for index in range(100):
        mnist_image_raw = autoEncode_images[index]
        mnist_image_hacked = np.copy(mnist_image_raw)
        mnist_image_hacked=mnist_image_hacked.reshape(28*28)
        mnist_image_hacked = np.expand_dims(mnist_image_hacked, axis=0)
        preds = model.predict(mnist_image_hacked)

        autoEncode_images[index] = preds

    autoEncode_images = autoEncode_images.reshape((100, 28, 28, 1))
    image = get_images(autoEncode_images)
    image = (image / 2.0 + 0.5) * 255.0
    Image.fromarray(image.astype(np.uint8)).save("./hackAutoEncode/100mnist-hacked-autoEncode-b.png")

    image = 255.0-image
    Image.fromarray(image.astype(np.uint8)).save("./hackAutoEncode/100mnist-hacked-autoEncode-w.png")

    # 灰度图像里面黑是0 白是255 可以把中间状态的处理下
    image[image > 127] = 255
    Image.fromarray(image.astype(np.uint8)).save("./hackAutoEncode/100mnist-hacked-autoEncode-w-good.png")
img_name = "creative_commons_elephant.jpg"
img_cam_name = "elephant_cam.jpg"
img = image.load_img(img_path + img_name, target_size=(224, 224))
x = image.img_to_array(img)  # 形状为(224,224,3)的float32格式的Numpy数组
x = np.expand_dims(x, axis=0)  # 形状为(1,224,224,3)的float32格式的Numpy数组
x = preprocess_input(x)  # 对输入数据进行预处理(按通道进行颜色标准化)
# 使用VGG16模型预测图片的类别
preds = model.predict(x)
print("预测结果:", decode_predictions(preds, top=3)[0])
print("预测结果对应的编号:", np.argmax(preds[0]))

print("Code 5-42:使用 Grid-CAM 算法寻找图像中哪些部分最像非洲象")
african_elephant_output = model.output[:, 386]
last_conv_layer = model.get_layer('block5_conv3')
# K.gradients()报错cost must be a scalar。是因为 Theano 不支持,请切换成 TensorFlow
grads = K.gradients(african_elephant_output, last_conv_layer.output)[0]
pooled_grads = K.mean(grads, axis=(0, 1, 2))
iterate = K.function([model.input], [pooled_grads, last_conv_layer.output[0]])
pooled_grads_value, conv_layer_output_value = iterate([x])
for i in range(512):
    conv_layer_output_value[:, :, i] *= pooled_grads_value[i]
    pass

print("Code 5-43:绘制热力图")
heatmap = np.mean(conv_layer_output_value, axis=-1)
heatmap = np.maximum(heatmap, 0)
heatmap /= np.max(heatmap)
plt.matshow(heatmap)
plt.title("图5-35:测试图像的“非洲象”类激活热力图")

print("Code 5-44:将热力图与原始图像叠加")
Exemplo n.º 51
0
def model_hander(idx, input_size=224, ch=3, iter_num=40):
    # [memo]
    #   描画された filter がノイズっぽい場合は
    #       iteration の回数が足りない可能性..

    model = VGG16(weights='imagenet',
                  include_top=False)

    model.summary()
    print("\n")

    # select layer & filter number ----------
    layer_name = 'block5_conv3'
    filter_index = idx
    print("\nget filter: {} in layer: {}".format(filter_index, layer_name))

    # target層の n番目のフィルタの活性化を最大化する損失関数を定義
    layer_output = model.get_layer(layer_name).output
    print("\nlayer output: ", layer_output)  # Tensor("block5_conv3/Relu:0", shape=(None, None, None, 512), dtype=float32)
    print("type(layer output): ", type(layer_output))  # <class 'tensorflow.python.framework.ops.Tensor'>

    loss = K.mean(layer_output[:, :, :, filter_index])
    print("\nloss: ", loss)  # loss:  Tensor("Mean:0", shape=(), dtype=float32)
    print("type(loss): ", type(loss))  # <class 'tensorflow.python.framework.ops.Tensor'>

    # 入力に関する損失関数の勾配を取得
    #   gradients の戻り値はテンソルのリスト (今回の場合は サイズ1 のリスト)
    #   このため、リストの 0番目の要素だけを持つようにしている。
    grads = K.gradients(loss, model.input)[0]
    print("\ngrads all: ", K.gradients(loss, model.input))  # grads all:  [<tf.Tensor 'gradients_1/block1_conv1/convolution_grad/Conv2DBackpropInput:0' shape=(None, None, None, 3) dtype=float32>]
    print("\ngrads: ", grads)  # Tensor("gradients/block1_conv1/convolution_grad/Conv2DBackpropInput:0", shape=(None, None, None, 3), dtype=float32)
    print("type(grads): ", type(grads))  # <class 'tensorflow.python.framework.ops.Tensor'>

    
    # 勾配の正規化
    #   1e-5 を足しているのは 0 除算回避のため
    grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5)

    # 入力画像に基づいて、損失テンソルと勾配テンソルを計算する。
    #   iterate は引数に Numpy のテンソル (サイズ 1 のテンソルのリスト) をとり
    #   戻り値に 2つの Numpy テンソル (損失値と勾配値) のリストを返す関数として
    #   keras の backend 関数で定義。
    iterate = K.function([model.input], [loss, grads])
    print("\niter: ", iterate)  #  <tensorflow.python.keras.backend.EagerExecutionFunction object at 0x13d7f6f60>
    print("type(iter): ", type(iterate)) # <class 'tensorflow.python.keras.backend.EagerExecutionFunction'>
    

    # test
    #loss_value, grads_value = iterate([np.zeros((1, input_size, input_size, 3))])

    # input として ノイズが入ったグレースケール画像を使用
    input_img = np.random.random((1, input_size, input_size, ch))*20 + 128.

    """
    print("\nshowing input image...")
    plt.imshow(input_img[0]/255)
    plt.show()
    """

    # 勾配上昇法を 40 step 実行
    print("started gradient accendant...")
    lr = 1  # 各勾配の更新の大きさ
    for i in range(iter_num):
        # 損失関数と勾配を計算
        loss_val, grads_val = iterate([input_img])
        #print("  loss_val: ", loss_val)
        #print("  grads_val: ", grads_val)
        input_img += grads_val*lr
        print("  => Now step {} has done.".format(i+1))

    img = input_img[0]

    return img
Exemplo n.º 52
0
def generate_movie(steps, movie_name, *, target_size):
    if not steps:
        steps = random.sample(list(range(512)), 10)
    layer = layer_dict[LAYER_NAME]
    input_img = model.input

    sizes = []
    next_size = target_size
    for i in range(SCALE_STEPS):
        sizes.insert(0, int(next_size))
        next_size *= 0.9

    initial_size, *sizes = sizes
    img_data = np.random.uniform(size=(1, initial_size, initial_size,
                                       3)) + 128.
    loss = K.mean(layer.output[:, :, :, steps[0]])

    print('about to start.')
    grads = K.gradients(loss, input_img)[0]
    grads = normalize(grads)
    iterate = K.function([input_img], [loss, grads])

    for octave, size in enumerate(sizes):
        img_data = resize_img(img_data, (size, size))
        loss_value, grads_value = iterate([img_data])
        img_data += grads_value
    print('initialized.')

    scaled = int(target_size * 1.05)
    with imageio.get_writer(movie_name, mode='I', fps=25) as writer:
        pairs = list(zip(steps[:-1], steps[1:]))
        for prev_step, next_step in tqdm(pairs):
            for i in range(SCALE_STEPS * 3):
                weight = max(1.0, i / SCALE_STEPS)
                loss = (K.mean(layer.output[:, :, :, next_step]) * weight +
                        K.mean(layer.output[:, :, :, prev_step]) *
                        (1 - weight))
                grads = K.gradients(loss, input_img)[0]
                grads = normalize(grads)
                iterate = K.function([input_img], [loss, grads])
                img_data = resize_img(img_data, (scaled, scaled))
                start = (scaled - target_size) // 2
                # center crop
                img_data = img_data[:, start:start + target_size,
                                    start:start + target_size, :]
                # add a little noise
                img_data += np.random.uniform(size=(1, target_size,
                                                    target_size, 3)) * 16
                for i in range(7):
                    loss_value, grads_value = iterate([img_data])
                    if i == 0:
                        grads_value[0, :, :, 0] = ndimage.gaussian_filter(
                            grads_value[0, :, :, 0], sigma=2)
                        grads_value[0, :, :, 1] = ndimage.gaussian_filter(
                            grads_value[0, :, :, 1], sigma=2)
                        grads_value[0, :, :, 2] = ndimage.gaussian_filter(
                            grads_value[0, :, :, 2], sigma=2)
                    img_data += grads_value
                img_data[0] = visstd(img_data[0])
                writer.append_data(np.uint8(img_data[0]))
            prev_step = next_step
Exemplo n.º 53
0
    def __init__(
            self,
            model,
            bounds,
            channel_axis="auto",
            preprocessing=(0, 1),
            predicts="probabilities",
    ):
        from keras import backend as K

        if channel_axis == "auto":
            if K.image_data_format() == "channels_first":
                channel_axis = 1
            else:
                channel_axis = 3

        super(KerasModel, self).__init__(bounds=bounds,
                                         channel_axis=channel_axis,
                                         preprocessing=preprocessing)

        import keras
        from pkg_resources import parse_version

        assert parse_version(keras.__version__) >= parse_version(
            "2.0.7"), "Keras version needs to be 2.0.7 or newer"

        if predicts == "probs":
            predicts = "probabilities"
        assert predicts in ["probabilities", "logits"]

        inputs = model.input
        labels = K.placeholder(shape=(None, ))
        predictions = model.output

        shape = K.int_shape(predictions)
        _, num_classes = shape
        assert num_classes is not None

        self._num_classes = num_classes

        if predicts == "probabilities":
            if K.backend() == "tensorflow":
                (predictions, ) = predictions.op.inputs
                loss = K.sparse_categorical_crossentropy(labels,
                                                         predictions,
                                                         from_logits=True)
            else:  # pragma: no cover
                logging.warning(
                    "relying on numerically unstable conversion from probabilities to softmax"
                )
                loss = K.sparse_categorical_crossentropy(labels,
                                                         predictions,
                                                         from_logits=False)

                # transform the probability predictions into logits, so that
                # the rest of this code can assume predictions to be logits
                predictions = self._to_logits(predictions)
        elif predicts == "logits":
            loss = K.sparse_categorical_crossentropy(labels,
                                                     predictions,
                                                     from_logits=True)

        loss = K.sum(loss, axis=0)
        (gradient, ) = K.gradients(loss, [inputs])

        backward_grad_logits = K.placeholder(shape=predictions.shape)
        backward_loss = K.sum(K.batch_dot(predictions,
                                          backward_grad_logits,
                                          axes=-1),
                              axis=0)
        (backward_grad_inputs, ) = K.gradients(backward_loss, [inputs])

        self._loss_fn = K.function([inputs, labels], [loss])
        self._forward_fn = K.function([inputs], [predictions])
        self._gradient_fn = K.function([inputs, labels], [gradient])
        self._backward_fn = K.function([backward_grad_logits, inputs],
                                       [backward_grad_inputs])
        self._forward_and_gradient_fn = K.function([inputs, labels],
                                                   [predictions, gradient])
Exemplo n.º 54
0
def get_kept_filters(layer_dict,
                    layer_name,
                    input_img,
                    image_width,
                    image_height,
                    m):
    kept_filters = []
    for filter_index in range(m):

        print('Processing filter %d' % filter_index)
        start_time = time.time()

        # funcion de perdida que amximiza la activacion del filtro
        layer_output = layer_dict[layer_name].output
        if K.image_data_format() == 'channels_first':
            loss = K.mean(layer_output[:, filter_index, :, :])
        else:
            loss = K.mean(layer_output[:, :, :, filter_index])

        # calcula el gradiente de la imagen inicial
        grads = K.gradients(loss, input_img)[0]

        # normalizar el gradiente
        grads = normalize(grads)

        # regresa la perdida y el gradiente 
        iterate = K.function([input_img], [loss, grads])

        # tamaño de paso
        step = 1.

        # una imagen gris con ruido aleatorio
        if K.image_data_format() == 'channels_first':
            input_img_data = np.random.random((1, 3, img_width, img_height))
        else:
            input_img_data = np.random.random((1, img_width, img_height, 3))
        input_img_data = (input_img_data - 0.5) * 20 + 128

        # ascenso del grandiente en 20 pasos
        for i in range(20):
            loss_value, grads_value = iterate([input_img_data])
            input_img_data += grads_value * step

            if loss_value <= 0.:
            # Eliminar filtros que se quedan en 0
                break

        # decodificar la imagen resultante
        if loss_value > 0:
            img = deprocess_image(input_img_data[0])
            kept_filters.append((img, loss_value))
        end_time = time.time()
        print('Filter %d processed in %ds' % (filter_index, end_time - start_time))

    n = len(kept_filters[0][0][0][0])
    kept_filters.sort(key=lambda x: x[1], reverse=True)
    kept_filters = kept_filters[:n * n]

    margin = 5
    width = n * img_width + (n - 1) * margin
    height = n * img_height + (n - 1) * margin
    stitched_filters = np.zeros((width, height, 3))

    # Guardar la imágen
    for i in range(n):
        for j in range(n):
            img, loss = kept_filters[i * n + j]
            stitched_filters[(img_width + margin) * i: (img_width + margin) * i + img_width,
                        (img_height + margin) * j: (img_height + margin) * j + img_height, :] = img

    # save the result to disk
    imsave('{layer}_{n}x{n}.png'.format(layer=layer_name, n=n), stitched_filters)
Exemplo n.º 55
0
required_tensor = a ** 2 + b ** 2 + c ** 2 + 2 * b * c

required_function = K.function(inputs=(a, b, c), outputs=(required_tensor,))

print("Exercise 1 complete")

# Exercise 2

"""x can be initialized in various ways
It can be initialized as either
x = K.variable(value=np.array(1))
Or it can initialized through one of K.ones(shape=()) or K.zeros(shape=())"""
x = K.ones(shape=())

tanh_tensor = (K.exp(x) - K.exp(-x)) / (K.exp(x) + K.exp(-x))
gradient_tensor_list = K.gradients(loss=tanh_tensor, variables=(tanh_tensor,))
"""Note that the above variable is a list of tensors each which holds
the gradient of the tanh_tensor with respect to each of the variables given
as the input. In this case, since there is only one variable, the
gradient_tensor_list is a list with only element in it"""

required_function = K.function(inputs=(x,),
                               outputs=[tanh_tensor] + gradient_tensor_list)
"""Note that the input for the parameter outputs above can either be a list or
a tuple. In the use above, we added two lists which would be concatenation
operation in python which results in a single list holding the elements in both
the lists"""

print("Exercise 2 complete")

# Exercise 3
Exemplo n.º 56
0
    # symbolic_conv_outputs = symbolic_conv_outputs[:2]

    # make a big model that outputs multiple layers' outputs
    multi_output_model = Model(vgg.input, symbolic_conv_outputs)

    # calculate the targets that are output at each layer
    style_layers_outputs = [
        K.variable(y) for y in multi_output_model.predict(x)
    ]

    # calculate the total style loss
    loss = 0
    for symbolic, actual in zip(symbolic_conv_outputs, style_layers_outputs):
        # gram_matrix() expects a (H, W, C) as input
        loss += style_loss(symbolic[0], actual[0])

    grads = K.gradients(loss, multi_output_model.input)

    # just like theano.function
    get_loss_and_grads = K.function(inputs=[multi_output_model.input],
                                    outputs=[loss] + grads)

    def get_loss_and_grads_wrapper(x_vec):
        l, g = get_loss_and_grads([x_vec.reshape(*batch_shape)])
        return l.astype(np.float64), g.flatten().astype(np.float64)

    final_img = minimize(get_loss_and_grads_wrapper, 10, batch_shape)
    plt.imshow(scale_img(final_img))
    plt.title('The essence of STYLE')
    plt.show()
Exemplo n.º 57
0
        for p in range(n_part_param_layers[layer_id])
    ])

trainable_count_id_start_end = np.insert(np.cumsum(trainable_count), 0, 0)

t = 0
FI_train_all = np.zeros(n_train)  # FI for all parameters

grad_K = tf.concat(
    axis=1,
    values=[
        tf.concat(
            axis=0,
            values=[
                K.flatten(b)[..., None]
                for b in K.gradients(model.output[0,
                                                  k], model.trainable_weights)
            ]) for k in range(n_class)
    ])

iterate = K.function([model.input], [grad_K, model.output])

for i in range(int(n_train * (set_part - 1)), int(n_train * set_part)):

    grad, pred_P = iterate([x_train[i][None]])

    L0 = grad @ np.diag(((pred_P[0, ])**0.5 + epsilon)**-1)

    f_grad = (grad[:, y_train[i]] /
              (pred_P[0, y_train[i]] + epsilon)).T  # shape=(1,...)

    #All trainable parameters
Exemplo n.º 58
0
    shape = layer_dict[layer_name].output_shape
    # we avoid border artifacts by only involving non-border pixels in the loss
    loss -= coeff * K.sum(K.square(x[:, :, 2:shape[2] - 2,
                                     2:shape[3] - 2])) / np.prod(shape[1:])

# add continuity loss (gives image local coherence, can result in an artful blur)
loss += settings['continuity'] * continuity_loss(dream) / (3 * img_width *
                                                           img_height)
# add image L2 norm to loss (prevents pixels from taking very high values, makes image darker)
loss += settings['dream_l2'] * K.sum(
    K.square(dream)) / (3 * img_width * img_height)

# feel free to further modify the loss as you see fit, to achieve new effects...

# compute the gradients of the dream wrt the loss
grads = K.gradients(loss, dream)

# set up helper functions to extract the loss and gradients
# from the computational graph as Numpy arrays
f_grads = K.function([dream], grads)


def eval_grads(x):
    x = x.reshape((1, 3, img_width, img_height))
    return np.array(f_grads([x])).flatten().astype('float64')


f_loss = K.function([dream], [loss])


def eval_loss(x):
    # 3. Build a cost function that minimizes the distance between the expected gain and actual gain
    # ----------------------------------------------------------------------------------------------
    l1_output_cb = contour_integration_model.layers[1].output
    l2_output_cb = contour_integration_model.layers[2].output
    input_cb = contour_integration_model.input

    # Mean Square Error Loss
    current_gain = l2_output_cb[:, tgt_filter_idx, tgt_neuron_loc, tgt_neuron_loc] / \
        (l1_output_cb[:, tgt_filter_idx, tgt_neuron_loc, tgt_neuron_loc] + 1e-5)
    loss = (expected_gains - current_gain)**2 / expected_gains.shape[0]

    alpha_cb = contour_integration_model.layers[2].alpha
    bias_cb = contour_integration_model.layers[2].bias

    # Gradients of alpha and bias wrt to the loss function
    grads = K.gradients(loss, [alpha_cb, bias_cb])
    grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5
              )  # Normalize gradients, prevents too large or small gradients

    iterate = K.function([input_cb], [loss, grads])

    # 4. Now iterate to find the best fit alpha and bias
    # --------------------------------------------------
    step = 0.025
    old_loss = 10000000

    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.set_xlabel("Iteration")
    ax.set_ylabel('Loss')
Exemplo n.º 60
0
loss = K.variable(0.0, name='Loss')
layer_features = outputs_dict[content_layer]
content_features = layer_features[0, :, :, :]
combination_features = layer_features[2, :, :, :]
loss += content_weight * content_loss(content_features, combination_features)

for layer_name in style_layers:
    layer_features = outputs_dict[layer_name]
    style_features = layer_features[1, :, :, :]
    combination_features = layer_features[2, :, :, :]
    sl = style_loss(style_features, combination_features)
    loss += (style_weight / len(style_layers)) * sl

loss += total_variation_weight * total_variation_loss(canvas)

grads = K.gradients(loss, canvas)[0]
fetch_loss_and_grads = K.function([canvas], [loss, grads])

initial = content.copy()
learning_rate = 1e-4
loss_history = []
iterations = 1000

for i in range(iterations):
    print(i)
    loss_i, grads_i = fetch_loss_and_grads([initial])
    initial -= learning_rate * grads_i
    loss_history.append(loss_i)
image = initial
K.clear_session()
image = image.reshape(canvas.shape)[0]