基于反卷积的卷积神经网络特征可视化.zip

import argparse import numpy as np import sys import time import images from PIL import Image from keras.preprocessing import image from keras.applications import VGG19 import keras.backend as K from keras.applications.vgg19 import preprocess_input from keras.layers import ( Input, InputLayer, Flatten, Activation, Dense) from keras.layers.convolutional import ( Convolution2D, MaxPooling2D) from keras.activations import * from keras.models import Model class DInput(object): ''' A class to define forward and backward operation on Input ''' def __init__(self, layer): ''' # Arguments layer: an instance of Input layer, whose configuration will be used to initiate DInput(input_shape, output_shape, weights) ''' self.layer = layer # input and output of Input layer are the same def up(self, data): ''' function to operate input in forward pass, the input and output are the same # Arguments data: Data to be operated in forward pass # Returns data ''' self.up_data = data return self.up_data def down(self, data): ''' function to operate input in backward pass, the input and output are the same # Arguments data: Data to be operated in backward pass # Returns data ''' self.down_data = data return self.down_data class DConvolution2D(object): ''' A class to define forward and backward operation on Convolution2D ''' def __init__(self, layer): ''' # Arguments layer: an instance of Convolution2D layer, whose configuration will be used to initiate DConvolution2D(input_shape, output_shape, weights) ''' self.layer = layer weights = layer.get_weights() W, b = weights config = layer.get_config() # Set up_func for DConvolution2D input = Input(shape=layer.input_shape[1:]) output = Convolution2D.from_config(config)(input) up_func = Model(input, output) up_func.layers[1].set_weights(weights) self.up_func = up_func # Flip W horizontally and vertically, # and set down_func for DConvolution2D W = np.transpose(W, (0, 1, 3, 2)) W = W[::-1, ::-1, :, :] config['filters'] = W.shape[3] config['kernel_size'] = (W.shape[0], W.shape[1]) b = np.zeros(config['filters']) input = Input(shape=layer.output_shape[1:]) output = Convolution2D.from_config(config)(input) down_func = Model(input, output) down_func.layers[1].set_weights((W, b)) self.down_func = down_func def up(self, data): ''' function to compute Convolution output in forward pass # Arguments data: Data to be operated in forward pass # Returns Convolved result ''' self.up_data = self.up_func.predict(data) return self.up_data def down(self, data): ''' function to compute Deconvolution output in backward pass # Arguments data: Data to be operated in backward pass # Returns Deconvolved result ''' self.down_data = self.down_func.predict(data) return self.down_data class DPooling(object): ''' A class to define forward and backward operation on Pooling ''' def __init__(self, layer): ''' # Arguments layer: an instance of Pooling layer, whose configuration will be used to initiate DPooling(input_shape, output_shape, weights) ''' self.layer = layer self.poolsize = layer.pool_size def up(self, data): ''' function to compute pooling output in forward pass # Arguments data: Data to be operated in forward pass # Returns Pooled result ''' [self.up_data, self.switch] = \ self.__max_pooling_with_switch(data, self.poolsize) return self.up_data def down(self, data): ''' function to compute unpooling output in backward pass # Arguments data: Data to be operated in forward pass # Returns Unpooled result ''' self.down_data = self.__max_unpooling_with_switch(data, self.switch) return self.down_data def __max_pooling_with_switch(self, input, poolsize): ''' Compute pooling output and switch in forward pass, switch stores location of the maximum value in each poolsize * poolsize block # Arguments input: data to be pooled poolsize: size of pooling operation # Returns Pooled result and Switch ''' switch = np.zeros(input.shape) out_shape = list(input.shape) row_poolsize = int(poolsize[0]) col_poolsize = int(poolsize[1]) out_shape[1] = out_shape[1] // poolsize[0] out_shape[2] = out_shape[2] // poolsize[1] pooled = np.zeros(out_shape) for sample in range(input.shape[0]): for dim in range(input.shape[3]): for row in range(out_shape[1]): for col in range(out_shape[2]): patch = input[sample, row * row_poolsize: (row + 1) * row_poolsize, col * col_poolsize: (col + 1) * col_poolsize, dim] max_value = patch.max() pooled[sample, row, col, dim] = max_value max_col_index = patch.argmax(axis=-1) max_cols = patch.max(axis=-1) max_row = max_cols.argmax() max_col = max_col_index[max_row] switch[sample, row * row_poolsize + max_row, col * col_poolsize + max_col, dim] = 1 return [pooled, switch] # Compute unpooled output using pooled data and switch def __max_unpooling_with_switch(self, input, switch): ''' Compute unpooled output using pooled data and switch # Arguments input: data to be pooled poolsize: size of pooling operation switch: switch storing location of each elements # Returns Unpooled result ''' out_shape = switch.shape unpooled = np.zeros(out_shape) for sample in range(input.shape[0]): for dim in range(input.shape[3]): tile = np.ones((switch.shape[1] // input.shape[1], switch.shape[2] // input.shape[2])) out = np.kron(input[sample, :, :, dim], tile) unpooled[sample, :, :, dim] = out * switch[sample, :, :, dim] return unpooled class DActivation(object): ''' A class to define forward and backward operation on Activation ''' def __init__(self, layer, linear=False): ''' # Arguments layer: an instance of Activation layer, whose configuration will be used to initiate DActivation(input_shape, output_shape, weights) ''' self.layer = layer self.linear = linear self.activation = layer.activation input = K.placeholder(shape=layer.output_shape) output = self.activation(inp