class InitialColumnProgNN(object): """ Descr: Initial network to train for later use transfer learning with a Progressive Neural Network. Args: topology - A list of number of units in each hidden dimension. First entry is input dimension. activations - A list of activation functions to use on the transforms. session - A TensorFlow session. Returns: None - attaches objects to class for InitialColumnProgNN.session.run() """ def __init__(self, topology, activations, session, checkpoint_base_path, dtype=tf.float32): n_input = topology[0] # Layers in network. L = len(topology) - 1 self.session = session self.L = L self.topology = topology self.checkpoint_base_path = checkpoint_base_path self.o_n = tf.placeholder(dtype, shape=[None, n_input], name='prog_nn_input_placeholder') self.W = [] self.b = [] self.h = [self.o_n] params = [] for k in range(L): shape = topology[k:k + 2] self.W.append( weight_variable(shape, name="weight_var_layer_" + str(k))) self.b.append( bias_variable([shape[1]], name="bias_var_layer_" + str(k))) self.h.append(activations[k](tf.matmul(self.h[-1], self.W[k]) + self.b[k])) params.append(self.W[-1]) params.append(self.b[-1]) self.pc = ParamCollection(self.session, params) def save(self, checkpoint_i): save_path = get_checkpoint_path(self.checkpoint_base_path, 0, checkpoint_i) current_params = self.pc.get_values_flat() np.save(save_path, current_params) def restore_weights(self, checkpoint_i): save_path = get_checkpoint_path(self.checkpoint_base_path, 0, checkpoint_i) saved_theta = np.load(save_path) self.pc.set_values_flat(saved_theta)
class ExtensibleColumnProgNN(object): """ Descr: An extensible network column for use in transfer learning with a Progressive Neural Network. Args: topology - A list of number of units in each hidden dimension. First entry is input dimension. activations - A list of activation functions to use on the transforms. session - A TensorFlow session. prev_columns - Previously trained columns, either Initial or Extensible, we are going to create lateral connections to for the current column. Returns: None - attaches objects to class for ExtensibleColumnProgNN.session.run() """ def __init__(self, topology, activations, session, checkpoint_base_path, prev_columns, dtype=tf.float32): n_input = topology[0] self.topology = topology self.session = session width = len(prev_columns) # Layers in network. First value is n_input, so it doesn't count. L = len(topology) - 1 self.L = L self.prev_columns = prev_columns self.checkpoint_base_path = checkpoint_base_path self.column_number = width # Doesn't work if the columns aren't the same height. assert all([self.L == x.L for x in prev_columns]) self.o_n = tf.placeholder(dtype, shape=[None, n_input], name='prog_nn_input_placeholder') self.W = [[]] * L self.b = [[]] * L self.U = [] for k in range(L - 1): self.U.append([[]] * width) self.h = [self.o_n] # Collect parameters to hand off to ParamCollection. params = [] for k in range(L): W_shape = topology[k:k + 2] self.W[k] = weight_variable(W_shape, name="weight_var_layer_" + str(k)) self.b[k] = bias_variable([W_shape[1]], name="bias_var_layer_" + str(k)) if k == 0: self.h.append(activations[k](tf.matmul(self.h[-1], self.W[k]) + self.b[k])) params.append(self.W[k]) params.append(self.b[k]) continue preactivation = tf.matmul(self.h[-1], self.W[k]) + self.b[k] for kk in range(width): U_shape = [prev_columns[kk].topology[k], topology[k + 1]] # Remember len(self.U) == L - 1! self.U[k - 1][kk] = weight_variable( U_shape, name="lateral_weight_var_layer_" + str(k) + "_to_column_" + str(kk)) # pprint(prev_columns[kk].h[k].get_shape().as_list()) # pprint(self.U[k-1][kk].get_shape().as_list()) preactivation += tf.matmul(prev_columns[kk].h[k], self.U[k - 1][kk]) self.h.append(activations[k](preactivation)) params.append(self.W[k]) params.append(self.b[k]) for kk in range(width): params.append(self.U[k - 1][kk]) self.pc = ParamCollection(self.session, params) def save(self, checkpoint_i): save_path = get_checkpoint_path(self.checkpoint_base_path, self.column_number, checkpoint_i) current_params = self.pc.get_values_flat() np.save(save_path, current_params) def restore_weights(self, checkpoint_i): save_path = get_checkpoint_path(self.checkpoint_base_path, self.column_number, checkpoint_i) saved_theta = np.load(save_path) self.pc.set_values_flat(saved_theta)
class InitialColumnProgNN(object): """ Descr: Initial network to train for later use transfer learning with a Progressive Neural Network. Args: n_input - The array length which the input image is flattened to kernel - A list of kernel size for each layer activations - A list of activation functions to use on the transforms. session - A TensorFlow session. checkpoing_base_path - Save path. Returns: None - attaches objects to class for InitialColumnProgNN.session.run() """ #todo:add name to enery tensor def __init__(self, n_input, kernel, stride, activations, session, checkpoint_base_path, dtype=tf.float32): # Layers in network. self.session = session #self.L = len(topology) #self.topology = topology self.o_n = tf.placeholder(dtype=tf.float32, shape=[None, n_input]) self.imageIn = tf.reshape(self.o_n, shape=[-1, 84, 84, 1]) self.checkpoint_base_path = checkpoint_base_path self.W = [] self.b = [] self.h = [self.imageIn] params = [] padding = 'SAME' #The first two layers for k in range(2): #When training on second column, if the previous weights need to be frozen, set initial=True, # the variables are set as not trainable. self.W.append(weight_variable(kernel[k], initial=None)) self.b.append(bias_variable([kernel[k][-1]], initial=None)) conv = tf.nn.conv2d(self.h[-1], self.W[k], stride[k], padding) + self.b[k] self.h.append(activations(conv)) params.append(self.W[k]) params.append(self.b[k]) self.h.append(tf.layers.flatten(self.h[-1])) #fully connected layer self.W.append(weight_variable(kernel[-1], initial=None)) self.b.append(bias_variable([kernel[-1][-1]], initial=None)) fc = tf.matmul(self.h[-1], self.W[-1]) + self.b[-1] self.h.append(activations(fc)) params.append(self.W[-1]) params.append(self.b[-1]) #Calculate value self.W.append(weight_variable([256, 1], initial=None)) self.b.append(bias_variable([1], initial=None)) self.value = tf.matmul(self.h[-1], self.W[-1]) + self.b[-1] params.append(self.W[-1]) params.append(self.b[-1]) #Calculate policy self.W.append(weight_variable([256, 6], initial=None)) self.b.append(bias_variable([6], initial=None)) fc = tf.matmul(self.h[-1], self.W[-1]) + self.b[-1] self.policy = tf.nn.softmax(fc) params.append(self.W[-1]) params.append(self.b[-1]) self.pc = ParamCollection(self.session, params) def add_input_to_feed_dict(self, feed_dict, input_batch): feed_dict[self.o_n] = input_batch return feed_dict def save(self, checkpoint_i): self.save_path, file_name = get_checkpoint_path( self.checkpoint_base_path, 0, checkpoint_i) current_params = self.pc.get_values_flat() np.save(file_name, current_params) def restore_weights(self, checkpoint_i): self.save_path, file_name = get_checkpoint_path( self.checkpoint_base_path, 0, checkpoint_i) saved_theta = np.load(file_name) self.pc.set_values_flat(saved_theta)
class ExtensibleColumnProgNN(object): """ Descr: An extensible network column for use in transfer learning with a Progressive Neural Network. Args: n_input - The array length which the input image is flattened to kernel - A list of kernel size for each layer activations - A list of activation functions to use on the transforms. session - A TensorFlow session. checkpoing_base_path - Save path. prev_columns - Previously trained columns, either Initial or Extensible, we are going to create lateral connections to for the current column. Returns: None - attaches objects to class for ExtensibleColumnProgNN.session.run() """ def __init__(self, n_input, kernel, stride, activations, session, checkpoint_base_path, prev_columns, dtype=tf.float32): self.session = session self.width = len(prev_columns) # Layers in network. First value is n_input, so it doesn't count. L = 5 self.prev_columns = prev_columns self.checkpoint_base_path = checkpoint_base_path # Doesn't work if the columns aren't the same height #assert all([L == x.L for x in prev_columns]) self.o_n = tf.placeholder(dtype=tf.float32, shape=[None, n_input]) self.imageIn = tf.reshape(self.o_n, shape=[-1, 84, 84, 1]) self.W = [[]] * L self.b = [[]] * L self.U = [] self.V = [] self.a = [] for k in range(L - 1): self.U.append([[]] * self.width) self.V.append([[]] * self.width) self.a.append([[]] * self.width) self.h = [self.imageIn] #h[0] # Collect parameters to hand off to ParamCollection. params = [] padding = 'SAME' #first layer, not connected with previous layers self.W[0] = (weight_variable(kernel[0])) self.b[0] = (bias_variable([kernel[0][-1]])) conv = tf.nn.conv2d(self.h[-1], self.W[0], stride[0], padding) + self.b[0] self.h.append(activations(conv)) #h[1] params.append(self.W[0]) params.append(self.b[0]) #second layer self.W[1] = (weight_variable(kernel[1])) self.b[1] = (bias_variable([kernel[1][-1]])) preactivation = tf.nn.conv2d(self.h[-1], self.W[1], stride[1], padding) + self.b[1] for kk in range(self.width): self.a[0][kk] = adapters() ah = tf.multiply(self.a[0][kk], prev_columns[kk].h[1]) maps_in = ah.get_shape().as_list()[3] maps_out = int(maps_in / (2.0 * self.width)) self.V[0][kk] = weight_variable([1, 1, maps_in, maps_out]) lateral = tf.nn.conv2d(ah, self.V[0][kk], stride[2], padding) lateral = activations(lateral) self.U[0][kk] = weight_variable( [kernel[1][0], kernel[1][1], maps_out, kernel[1][3]]) preactivation1 = tf.nn.conv2d(lateral, self.U[0][kk], stride[1], padding) preactivation = preactivation + preactivation1 self.h.append(activations(preactivation)) params.append(self.W[1]) params.append(self.b[1]) for kk in range(self.width): params.append(self.U[0][kk]) params.append(self.V[0][kk]) params.append(self.a[0][kk]) self.h.append(tf.layers.flatten(self.h[-1])) #h[3] #fully connected layer self.W[2] = (weight_variable(kernel[-1])) self.b[2] = (bias_variable([kernel[-1][-1]])) fc = tf.matmul(self.h[-1], self.W[2]) + self.b[2] for kk in range(self.width): self.a[1][kk] = adapters() ah = tf.multiply(self.a[1][kk], prev_columns[kk].h[2]) maps_in = ah.get_shape().as_list()[3] maps_out = int(maps_in / (2.0 * self.width)) self.V[1][kk] = weight_variable([1, 1, maps_in, maps_out]) lateral = tf.nn.conv2d(ah, self.V[1][kk], stride[2], padding) lateral = activations(lateral) #lateral = tf.reshape(lateral,[-1,kernel[-1][-1]]) lateral = tf.layers.flatten(lateral) self.U[1][kk] = weight_variable( [lateral.get_shape().as_list()[-1], kernel[-1][-1]]) fc += tf.matmul(lateral, self.U[1][kk]) self.h.append(activations(fc)) #h[4] params.append(self.W[2]) params.append(self.b[2]) for kk in range(self.width): params.append(self.U[1][kk]) params.append(self.V[1][kk]) params.append(self.a[1][kk]) #calculate value self.W[3] = (weight_variable([256, 1])) self.b[3] = (bias_variable([1])) self.value = tf.matmul(self.h[-1], self.W[3]) + self.b[3] for kk in range(self.width): self.a[2][kk] = adapters() ah = tf.multiply(self.a[2][kk], prev_columns[kk].h[4]) maps_in = ah.get_shape().as_list()[1] maps_out = int(maps_in / (2.0 * self.width)) self.V[2][kk] = weight_variable([maps_in, maps_out]) lateral = tf.matmul(ah, self.V[2][kk]) lateral = activations(lateral) self.U[2][kk] = weight_variable([maps_out, 1]) self.value += tf.matmul(lateral, self.U[2][kk]) params.append(self.W[3]) params.append(self.b[3]) for kk in range(self.width): params.append(self.U[2][kk]) params.append(self.V[2][kk]) params.append(self.a[2][kk]) #calculate policy self.W[4] = (weight_variable([256, 6])) self.b[4] = (bias_variable([6])) fc = tf.matmul(self.h[-1], self.W[4]) + self.b[4] for kk in range(self.width): self.a[3][kk] = adapters() ah = tf.multiply(self.a[3][kk], prev_columns[kk].h[4]) maps_in = ah.get_shape().as_list()[1] maps_out = int(maps_in / (2.0 * self.width)) self.V[3][kk] = weight_variable([maps_in, maps_out]) lateral = tf.matmul(ah, self.V[3][kk]) lateral = activations(lateral) self.U[3][kk] = weight_variable([maps_out, 6]) fc += tf.matmul(lateral, self.U[3][kk]) self.policy = tf.nn.softmax(fc) params.append(self.W[4]) params.append(self.b[4]) for kk in range(self.width): params.append(self.U[3][kk]) params.append(self.V[3][kk]) params.append(self.a[3][kk]) self.pc = ParamCollection(self.session, params) def add_input_to_feed_dict(self, feed_dict, input_batch): for col in self.prev_columns: feed_dict[col.o_n] = input_batch feed_dict[self.o_n] = input_batch return feed_dict def save(self, checkpoint_i): self.save_path, file_name = get_checkpoint_path( self.checkpoint_base_path, self.width, checkpoint_i) current_params = self.pc.get_values_flat() np.save(file_name, current_params) def restore_weights(self, checkpoint_i): self.save_path, file_name = get_checkpoint_path( self.checkpoint_base_path, self.width, checkpoint_i) saved_theta = np.load(file_name) self.pc.set_values_flat(saved_theta)