def create_model(): input_layer = Input(team_size * 2) embedding = Embedding(100, 1)(input_layer) embedding = Flatten()(embedding) team_a_embedding = embedding[:, :team_size] team_b_embedding = embedding[:, team_size:] dense = Dense(5, kernel_constraint=non_neg()) dense2 = Dense(5, kernel_constraint=non_neg()) densefinal = Dense(1, kernel_constraint=non_neg()) def multidense(x): return densefinal(dense2(dense(x))) # multidense = Lambda(lambda x: tf.math.reduce_sum(x,axis = 1, keepdims = True)/3) team_a_elo = multidense(team_a_embedding) team_b_elo = multidense(team_b_embedding) elos = Concatenate(axis=1)([team_a_elo, team_b_elo]) def loglike(win, elos): win = tf.cast(win, tf.float32) teamAelo = elos[:, 0] teamBelo = elos[:, 1] win = tf.reshape(win, [-1]) teamAlikelihood = 1 - 1 / (1 + math.e ** ((teamAelo - teamBelo) / scale)) teamBlikelihood = 1 / (1 + math.e ** ((teamAelo - teamBelo) / scale)) loglike = win * tf.math.log(teamAlikelihood) + (1 - win) * tf.math.log(teamBlikelihood) # import pdb; pdb.set_trace() return - tf.math.reduce_sum(loglike) opt = Adam(0.1) model = Model(input_layer, elos) model.compile(optimizer=opt, loss=loglike) return model
def build(self, input_shape): """ This method must be defined for any custom layer, here you define the training parameters. input_shape: a tensor that automatically captures the dimensions of the input by tensorflow. """ # retreive the number of waveguides self.num_wg = input_shape[-1] # define a list of trainable tensorflow parameters representing the coupling coefficients coupling_coeff = [] for idx_wg in range(self.num_wg): coupling_coeff.append( self.add_weight(name="e%s" % idx_wg, shape=tf.TensorShape(()), initializer=initializers.Constant(1.0), trainable=True, constraint=constraints.non_neg())) # convert the list of tensors to one tensor coupling_coeff = tf.convert_to_tensor(coupling_coeff) # add an extra dimension to represent time coupling_coeff = tf.expand_dims(coupling_coeff, 0) # add another dimension to represent batch coupling_coeff = tf.expand_dims(coupling_coeff, 0) # store this tensor as a class member so we can access it from othe methods in the class self.coupling_coeff = coupling_coeff # this has to be called for any tensorflow custom layer super(Coupling_Layer, self).build(input_shape)
def create_output_layers(x, x_row_splits, n_ccoords=2, add_beta=None, add_beta_weight=0.2, use_e_proxy=False, scale_exp_e=True, n_classes=0): beta = None if add_beta is not None: # the exact weighting can be learnt, but there has to be a positive correlation from tensorflow.keras.constraints import non_neg assert add_beta_weight < 1 n_adds = float(len(add_beta)) if isinstance(add_beta, list): add_beta = Concatenate()(add_beta) add_beta = ScalarMultiply(1. / n_adds)(add_beta) add_beta = Dense(1, activation='sigmoid', name="predicted_add_beta", kernel_constraint=non_neg(), # maybe it figures it out...? kernel_initializer='ones' )(add_beta) # tf.print(add_beta) add_beta = ScalarMultiply(add_beta_weight)(add_beta) beta = Dense(1, activation='sigmoid', name="pre_predicted_beta")(x) beta = ScalarMultiply(1 - add_beta_weight)(beta) beta = Add(name="predicted_beta")([beta, add_beta]) else: beta = Dense(1, activation='sigmoid', name="predicted_beta")(x) # x_raw = BatchNormalization(momentum=0.6,name="pre_ccoords_bn")(raw_inputs) # pre_ccoords = Dense(64, activation='elu',name="pre_ccords")(Concatenate()([x,x_raw])) ccoords = Dense(2, activation=None, name="predicted_ccoords")(x) if n_ccoords > 2: ccoords = Concatenate()([ccoords, Dense(n_ccoords - 2, activation=None, name="predicted_ccoords_add")(x)]) xy = Dense(2, activation=None, name="predicted_positions", kernel_initializer='zeros')(x) t = Dense(1, activation=None, name="predicted_time", kernel_initializer='zeros')(x) t = ScalarMultiply(1e-9)(t) xyt = Concatenate()([xy, t]) energy = Dense(1, activation=None)(x) if scale_exp_e: energy = ExpMinusOne(name='predicted_energy')(energy) else: energy = ScalarMultiply(100.)(energy) if n_classes > 0: classes_scores = Dense(n_classes, activation=None, name="predicted_classification_scores")(x) return Concatenate(name="predicted_final")([beta, energy, xyt, ccoords, classes_scores]) else: return Concatenate(name="predicted_final")([beta, energy, xyt, ccoords])
def build(self, input_shape): """ This method must be defined for any custom layer, here you define the training parameters. input_shape: a tensor that automatically captures the dimensions of the input by tensorflow. """ # get the the number of paramters num_params = input_shape[-1].value # calcualte the number of waveguides p = N*(N+1)/2 self.num_wg = int(np.sqrt(2 * num_params + 0.25) - 0.5) self.beta0 = self.add_weight(name="beta0", shape=tf.TensorShape((num_params, )), initializer=initializers.Constant(100.0), trainable=True, constraint=constraints.non_neg()) # this has to be called for any tensorflow custom layer super(Param_to_Ham_Layer, self).build(input_shape)
def retain(ARGS): """Create the model""" # Define the constant for model saving reshape_size = ARGS.emb_size + ARGS.numeric_size if ARGS.allow_negative: embeddings_constraint = FreezePadding() beta_activation = 'tanh' output_constraint = None else: embeddings_constraint = FreezePadding_Non_Negative() beta_activation = 'sigmoid' output_constraint = non_neg() def reshape(data): """Reshape the context vectors to 3D vector""" return K.reshape(x=data, shape=(K.shape(data)[0], 1, reshape_size)) # Code Input codes = L.Input((None, None), name='codes_input') inputs_list = [codes] # Calculate embedding for each code and sum them to a visit level codes_embs_total = L.Embedding( ARGS.num_codes + 1, ARGS.emb_size, name='embedding' # BUG: embeddings_constraint not supported # https://github.com/tensorflow/tensorflow/issues/33755 # ,embeddings_constraint=embeddings_constraint )(codes) codes_embs = L.Lambda(lambda x: K.sum(x, axis=2))(codes_embs_total) # Numeric input if needed if ARGS.numeric_size > 0: numerics = L.Input((None, ARGS.numeric_size), name='numeric_input') inputs_list.append(numerics) full_embs = L.concatenate([codes_embs, numerics], name='catInp') else: full_embs = codes_embs # Apply dropout on inputs full_embs = L.Dropout(ARGS.dropout_input)(full_embs) # Time input if needed if ARGS.use_time: time = L.Input((None, 1), name='time_input') inputs_list.append(time) time_embs = L.concatenate([full_embs, time], name='catInp2') else: time_embs = full_embs # Setup Layers # This implementation uses Bidirectional LSTM instead of reverse order # (see https://github.com/mp2893/retain/issues/3 for more details) # If training on GPU and Tensorflow use CuDNNLSTM for much faster training if glist: alpha = L.Bidirectional(L.CuDNNLSTM(ARGS.recurrent_size, return_sequences=True), name='alpha') beta = L.Bidirectional(L.CuDNNLSTM(ARGS.recurrent_size, return_sequences=True), name='beta') else: alpha = L.Bidirectional(L.LSTM(ARGS.recurrent_size, return_sequences=True, implementation=2), name='alpha') beta = L.Bidirectional(L.LSTM(ARGS.recurrent_size, return_sequences=True, implementation=2), name='beta') alpha_dense = L.Dense(1, kernel_regularizer=l2(ARGS.l2)) beta_dense = L.Dense(ARGS.emb_size + ARGS.numeric_size, activation=beta_activation, kernel_regularizer=l2(ARGS.l2)) # Compute alpha, visit attention alpha_out = alpha(time_embs) alpha_out = L.TimeDistributed(alpha_dense, name='alpha_dense_0')(alpha_out) alpha_out = L.Softmax(axis=1)(alpha_out) # Compute beta, codes attention beta_out = beta(time_embs) beta_out = L.TimeDistributed(beta_dense, name='beta_dense_0')(beta_out) # Compute context vector based on attentions and embeddings c_t = L.Multiply()([alpha_out, beta_out, full_embs]) c_t = L.Lambda(lambda x: K.sum(x, axis=1))(c_t) # Reshape to 3d vector for consistency between Many to Many and Many to One implementations contexts = L.Lambda(reshape)(c_t) # Make a prediction contexts = L.Dropout(ARGS.dropout_context)(contexts) output_layer = L.Dense(1, activation='sigmoid', name='dOut', kernel_regularizer=l2(ARGS.l2), kernel_constraint=output_constraint) # TimeDistributed is used for consistency # between Many to Many and Many to One implementations output = L.TimeDistributed(output_layer, name='time_distributed_out')(contexts) # Define the model with appropriate inputs model = Model(inputs=inputs_list, outputs=[output]) return model
def build(self,input_shape): """ This method must be defined for any custom layer, here you define the training parameters. input_shape: a tensor that automatically captures the dimensions of the input by tensorflow. """ # get the the number of paramters num_params = input_shape.as_list()[-1] # calculate the number of waveguides p = N*(N+1)/2 self.num_wg = int( np.sqrt(2*num_params + 0.25) - 0.5 ) self.beta0 = self.add_weight(name="beta0", shape=tf.TensorShape((num_params,)), initializer=initializers.Constant(100.0),trainable=True, constraint = constraints.non_neg()) # construct a matrix operator to rearrange the elements to be upper triangular r1 = 0 r2 = 0 A = np.zeros((self.num_wg**2,num_params)) for k in range(0,self.num_wg): for i in range(0,self.num_wg-k): A[i+r2, i+r1] = 1 r1 = r1 + (self.num_wg-k) r2 = r2 + k+1 + (self.num_wg-k) self.tri_op = tf.constant(np.reshape(A, (1,1,self.num_wg**2,num_params)), dtype=tf.float32) # this has to be called for any tensorflow custom layer super(Param_to_Ham_Layer, self).build(input_shape)
def build(self,input_shape): """ This method must be defined for any custom layer, here you define the training parameters. input_shape: a tensor that automatically captures the dimensions of the input by tensorflow. """ # retreive the number of waveguides self.num_wg = input_shape.as_list()[-1] # define the tensorflow parameters representing the coupling coefficients self.coupling_coeff = self.add_weight(name="e", shape=(1,1, self.num_wg), initializer=initializers.Constant(1.0), trainable=True, constraint = constraints.non_neg()) # this has to be called for any tensorflow custom layer super(Coupling_Layer, self).build(input_shape)
def retain(ARGS): """ Helper function to create DAG of Keras Layers via functional API approach. The Keras Layer design is mimicking RETAIN architecture. :param ARGS: Arguments object containing user-specified parameters :type ARGS: :class:`argparse.Namespace` :return: Keras model :rtype: :class:`tensorflow.keras.Model` """ #Define the constant for model saving reshape_size = ARGS.emb_size + ARGS.numeric_size if ARGS.allow_negative: embeddings_constraint = FreezePadding() beta_activation = 'tanh' output_constraint = None else: embeddings_constraint = FreezePadding_Non_Negative() beta_activation = 'sigmoid' output_constraint = non_neg() def reshape(data): """Reshape the context vectors to 3D vector""" return K.reshape(x=data, shape=(K.shape(data)[0], 1, reshape_size)) #Code Input codes = L.Input((None, None), name='codes_input') inputs_list = [codes] #Calculate embedding for each code and sum them to a visit level codes_embs_total = L.Embedding(ARGS.num_codes + 1, ARGS.emb_size, name='embedding')(codes) codes_embs = L.Lambda(lambda x: K.sum(x, axis=2))(codes_embs_total) #Numeric input if needed if ARGS.numeric_size: numerics = L.Input((None, ARGS.numeric_size), name='numeric_input') inputs_list.append(numerics) full_embs = L.concatenate([codes_embs, numerics], name='catInp') else: full_embs = codes_embs #Apply dropout on inputs full_embs = L.Dropout(ARGS.dropout_input)(full_embs) #Time input if needed if ARGS.use_time: time = L.Input((None, 1), name='time_input') inputs_list.append(time) time_embs = L.concatenate([full_embs, time], name='catInp2') else: time_embs = full_embs #Setup Layers #This implementation uses Bidirectional LSTM instead of reverse order # (see https://github.com/mp2893/retain/issues/3 for more details) alpha = L.Bidirectional(L.LSTM(ARGS.recurrent_size, return_sequences=True, implementation=2), name='alpha') beta = L.Bidirectional(L.LSTM(ARGS.recurrent_size, return_sequences=True, implementation=2), name='beta') alpha_dense = L.Dense(1, kernel_regularizer=l2(ARGS.l2)) beta_dense = L.Dense(ARGS.emb_size + ARGS.numeric_size, activation=beta_activation, kernel_regularizer=l2(ARGS.l2)) #Compute alpha, visit attention alpha_out = alpha(time_embs) alpha_out = L.TimeDistributed(alpha_dense, name='alpha_dense_0')(alpha_out) alpha_out = L.Softmax(name='softmax_1', axis=1)(alpha_out) #Compute beta, codes attention beta_out = beta(time_embs) beta_out = L.TimeDistributed(beta_dense, name='beta_dense_0')(beta_out) #Compute context vector based on attentions and embeddings c_t = L.Multiply()([alpha_out, beta_out, full_embs]) c_t = L.Lambda(lambda x: K.sum(x, axis=1))(c_t) #Reshape to 3d vector for consistency between Many to Many and Many to One implementations contexts = L.Lambda(reshape)(c_t) #Make a prediction contexts = L.Dropout(ARGS.dropout_context)(contexts) output_layer = L.Dense(1, activation='sigmoid', name='dOut', kernel_regularizer=l2(ARGS.l2), kernel_constraint=output_constraint) #TimeDistributed is used for consistency # between Many to Many and Many to One implementations output = L.TimeDistributed(output_layer, name='time_distributed_out')(contexts) #Define the model with appropriate inputs model = Model(inputs=inputs_list, outputs=[output]) return model
def __init__(self, units): super(Motor_thal, self).__init__() unit1 = units[0] unit2 = units[1] unit3 = units[2] self.units = unit2 * 3 self.input_dim = (unit2 * 3) + unit3 self.training = True w_init = tf.random_uniform_initializer(minval=0., maxval=0.01) z_init = tf.zeros_initializer() mthal_bias = [0, 0] b_init = tf.random_uniform_initializer(minval=mthal_bias[0], maxval=mthal_bias[1]) #split mthal into thirds. The middle layer is a transition layer limit_1 = unit2 limit_2 = unit2 * 2 limit_3 = unit2 * 3 #GPi input self.gpi_1_len = unit2 self.gpi_2_len = unit2 * 2 self.gpi_3_len = unit2 * 3 #premotor_input self.premotor_1_len = (unit2 * 3) + unit3 self.unit_diags = [] for unit in range(self.units): unit_diag = [] for input in range(self.input_dim): #mthal_1 if unit in range(limit_1): if input in range(self.gpi_1_len): #100% of self.gpi_1 -> mthal_1 unit_diag.append(1) elif input in range(self.gpi_1_len, self.gpi_2_len): #50% self.gpi_2 -> mthal_1 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.gpi_2_len, self.gpi_3_len): #0% of self.gpi_3 -> mthal_1 unit_diag.append(0) elif input in range(self.gpi_3_len, self.premotor_1_len): #100% self.premotor1 -> mthal_1 unit_diag.append(1) #mthal_2 elif unit in range(limit_1, limit_2): if input in range(self.gpi_1_len): #50% self.gpi_2 -> mthal_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.gpi_1_len, self.gpi_2_len): #75% self.gpi_2 -> mthal_2 if random.randint(4) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.gpi_2_len, self.gpi_3_len): #50% self.gpi_3 -> mthal_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.gpi_3_len, self.premotor_1_len): #90% self.premotor1 -> mthal_2 if random.randint(10) > 0: unit_diag.append(1) else: unit_diag.append(0) #mthal_3 elif unit in range(limit_2, limit_3): if input in range(self.gpi_1_len): #0% self.gpi_1 -> mthal_3 unit_diag.append(0) elif input in range(self.gpi_1_len, self.gpi_2_len): #50% self.gpi_2 -> mthal_3 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.gpi_2_len, self.gpi_3_len): #100% self.gpi_3 -> mthal_3 unit_diag.append(1) elif input in range(self.gpi_3_len, self.premotor_1_len): #80% self.premotor1 -> mthal_3 if random.randint(10) > 1: unit_diag.append(1) else: unit_diag.append(0) self.unit_diags.append(np.array(unit_diag)) self.unit_diags = np.array(self.unit_diags) if use_constraints: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True, constraint=non_neg()) else: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True) #biases self.b = self.add_weight(shape=(self.units, ), initializer=b_init, trainable=True) self.s = tf.convert_to_tensor(np.array([ sparse.diags(self.unit_diags[i], 0).toarray() for i in range(len(self.unit_diags)) ]), dtype=tf.float32)
def __init__(self, units, str_dval=[]): super(GPi, self).__init__() unit1 = units[0] unit2 = units[1] unit3 = units[2] self.units = unit2 * 3 self.input_dim = (unit1 + unit2) * 3 self.training = True w_init = tf.random_uniform_initializer(minval=0., maxval=0.01) z_init = tf.zeros_initializer() gpi_bias = [0, 0] b_init = tf.random_uniform_initializer( minval=gpi_bias[0], maxval=gpi_bias[1] ) #give them a positive bias; they will 'output' at baseline #will be a tough hyperparam to tune #split GPi into thirds. limit_1 = unit2 limit_2 = unit2 * 2 limit_3 = unit2 * 3 #dorsal striatum input self.ds1_len = unit1 self.ds2_len = unit1 * 2 self.ds3_len = unit1 * 3 self.stn1_len = unit1 * 3 + unit2 self.stn2_len = unit1 * 3 + unit2 * 2 self.stn3_len = unit1 * 3 + unit2 * 3 self.str_dval = str_dval self.unit_diags = [] for unit in range(self.units): unit_diag = [] for input in range(self.input_dim): if input < len(self.str_dval): if self.str_dval[input] == 2: #if D2, don't pass through unit_diag.append(0) continue #GPi_1 if unit in range(limit_1): if input in range(self.ds1_len): #100% dorsal striatum_1 -> GPi_1 unit_diag.append(1) elif input in range(self.ds1_len, self.ds2_len): #50% self.ds_2 -> GPi_1 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.ds2_len, self.ds3_len): #0% self.ds_3 -> GPi_1 unit_diag.append(0) elif input in range(self.ds3_len, self.stn1_len): #100% self.stn_1 -> GPi_1 unit_diag.append(1) elif input in range(self.stn1_len, self.stn2_len): #50% self.stn_2 -> GPi_1 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.stn2_len, self.stn3_len): #0% of self.stn_3 -> GPi_1 unit_diag.append(0) #GPi_2 elif unit in range(limit_1, limit_2): if input in range(self.ds1_len): #50% self.ds_1 -> GPi_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.ds1_len, self.ds2_len): #75% self.ds_2 -> GPi_2 if random.randint(4) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.ds2_len, self.ds3_len): #50% self.ds_3 -> GPi_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.stn1_len): #50% self.stn_1 -> GPi_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.stn1_len, self.stn2_len): #75% self.stn_2 -> GPi_2 if random.randint(4) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.stn2_len, self.stn3_len): #50% self.stn_3 -> GPi_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) #GPi_3 elif unit in range(limit_2, limit_3): if input in range(self.ds1_len): #0% self.ds_1 -> GPi_3 unit_diag.append(0) elif input in range(self.ds1_len, self.ds2_len): #50% self.ds_2 -> GPi_3 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.ds2_len, self.ds3_len): #100% self.ds_3 -> GPi_3 unit_diag.append(1) elif input in range(self.stn1_len): #0% self.stn_1 -> GPi_3 unit_diag.append(0) elif input in range(self.stn1_len, self.stn2_len): #50% self.stn_2 -> GPi_3 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(self.stn2_len, self.stn3_len): #100% self.stn_3 -> GPi_3 unit_diag.append(1) self.unit_diags.append(np.array(unit_diag)) self.unit_diags = np.array(self.unit_diags) if use_constraints: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True, constraint=non_neg()) else: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True) #positive biases self.b = self.add_weight(shape=(self.units, ), initializer=b_init, trainable=True) self.s = tf.convert_to_tensor(np.array([ sparse.diags(self.unit_diags[i], 0).toarray() for i in range(len(self.unit_diags)) ]), dtype=tf.float32)
def __init__(self, units): super(STN, self).__init__() unit1 = units[0] unit2 = units[1] unit3 = units[2] self.units = unit2 * 3 self.input_dim = unit2 * 3 self.training = True w_init = tf.random_uniform_initializer(minval=0., maxval=0.01) z_init = tf.zeros_initializer() stn_bias = [0, 0] b_init = tf.random_uniform_initializer( minval=stn_bias[0], maxval=stn_bias[1] ) #give them a positive bias; they will 'output' at baseline #will be a tough hyperparam to tune #split STN into thirds. The middle layer is a transition layer limit_1 = unit2 limit_2 = unit2 * 2 limit_3 = unit2 * 3 #GPe input gpe_1_len = unit2 gpe_2_len = unit2 * 2 gpe_3_len = unit2 * 3 self.unit_diags = [] for unit in range(self.units): unit_diag = [] for input in range(self.input_dim): #STN_1 if unit in range(limit_1): if input in range(gpe_1_len): #100% of gpe_1 -> STN_1 unit_diag.append(1) elif input in range(gpe_1_len, gpe_2_len): #50% gpe_2 -> STN_1 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(gpe_2_len, gpe_3_len): #0% of gpe_3 -> STN_1 unit_diag.append(0) #STN_2 elif unit in range(limit_1, limit_2): if input in range(gpe_1_len): #50% gpe_2 -> STN_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(gpe_1_len, gpe_2_len): #75% gpe_2 -> STN_2 if random.randint(4) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(gpe_2_len, gpe_3_len): #50% gpe_3 -> STN_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) #STN_3 elif unit in range(limit_2, limit_3): if input in range(gpe_1_len): #0% gpe_1 -> STN_3 unit_diag.append(0) elif input in range(gpe_1_len, gpe_2_len): #50% gpe_2 -> STN_3 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(gpe_2_len, gpe_3_len): #100% gpe_3 -> STN_3 unit_diag.append(1) self.unit_diags.append(np.array(unit_diag)) self.unit_diags = np.array(self.unit_diags) if use_constraints: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True, constraint=non_neg()) else: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True) #biases self.b = self.add_weight(shape=(self.units, ), initializer=b_init, trainable=True) self.s = tf.convert_to_tensor(np.array([ sparse.diags(self.unit_diags[i], 0).toarray() for i in range(len(self.unit_diags)) ]), dtype=tf.float32)
def __init__(self, units, input_dim=15): super(Striatum, self).__init__() unit1 = units[0] unit2 = units[1] unit3 = units[2] self.units = unit1 * 3 self.input_dim = input_dim self.training = True w_init = tf.random_uniform_initializer(minval=0., maxval=0.01) z_init = tf.zeros_initializer() str_bias = [0, 0] b_init = tf.random_uniform_initializer(minval=str_bias[0], maxval=str_bias[1]) #self.w = [] limit_1 = unit1 limit_2 = unit1 * 2 limit_3 = unit1 * 3 goal_len = 3 color_len = 6 pos_len = 9 act_len = 15 self.dval = [] self.unit_diags = [] for unit in range(self.units): #for each unit, rand int, 50%, make it D1 or D2 if random.randint(2) > 0: self.dval.append(1) else: self.dval.append(2) unit_diag = [] for input in range(self.input_dim): #D1 if unit in range(limit_1): if input in range(goal_len): #100% goal in D1 unit_diag.append(1) elif input in range(goal_len, color_len): #40% color in D1 if random.randint(5) > 2: unit_diag.append(1) else: unit_diag.append(0) elif input in range(color_len, pos_len): #10% pos in D1 if random.randint(10) > 8: unit_diag.append(1) else: unit_diag.append(0) elif input in range(pos_len, act_len): #0% last action in D1 unit_diag.append(0) #D2 elif unit in range(limit_1, limit_2): if input in range(goal_len): #%50 goal in D2 if random.randint(10) > 4: unit_diag.append(1) else: unit_diag.append(0) elif input in range(goal_len, color_len): #80% color in D2 if random.randint(5) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(color_len, pos_len): #60% pos in D2 if random.randint(5) > 1: unit_diag.append(1) else: unit_diag.append(0) elif input in range(pos_len, act_len): #20% last action to D1 if random.randint(10) > 7: unit_diag.append(1) else: unit_diag.append(0) #D3 elif unit in range(limit_2, limit_3): if input in range(goal_len): #%0 goal in D2 unit_diag.append(0) elif input in range(goal_len, color_len): #20% color in D2 if random.randint(5) > 3: unit_diag.append(1) else: unit_diag.append(0) elif input in range(color_len, pos_len): #100% pos in D2 unit_diag.append(1) elif input in range(pos_len, act_len): #100% last action to D1 unit_diag.append(1) self.unit_diags.append(np.array(unit_diag)) self.unit_diags = np.array(self.unit_diags) #biases -> Consider adding a negative bias if use_constraints: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True, constraint=non_neg()) else: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True) self.b = self.add_weight(shape=(self.units, ), initializer=b_init, trainable=True) self.s = tf.convert_to_tensor(np.array([ sparse.diags(self.unit_diags[i], 0).toarray() for i in range(len(self.unit_diags)) ]), dtype=tf.float32)
def __init__(self, units, str_dval=[]): super(GPe, self).__init__() unit1 = units[0] unit2 = units[1] unit3 = units[2] self.units = unit2 * 3 self.input_dim = unit1 * 3 self.training = True w_init = tf.random_uniform_initializer(minval=0., maxval=0.01) z_init = tf.zeros_initializer() gpe_bias = [0, 0] b_init = tf.random_uniform_initializer( minval=gpe_bias[0], maxval=gpe_bias[1] ) #give them a positive bias; they will 'output' at baseline #will be a tough hyperparam to tune #split GPe into thirds. The middle layer is really a transition layer is all limit_1 = unit2 limit_2 = unit2 * 2 limit_3 = unit2 * 3 #dorsal striatum input ds1_len = unit1 ds2_len = unit1 * 2 ds3_len = unit1 * 3 lateral_len = self.units #will use in future; will have to sum input_dim too, input_dim += units self.str_dval = str_dval self.unit_diags = [] for unit in range(self.units): unit_diag = [] for input in range(self.input_dim): if self.str_dval[input] == 1 and random.randint( 2) > 0: #if D1, only 50% pass through unit_diag.append(0) continue #GPe_1 if unit in range(limit_1): if input in range(ds1_len): #100% of dorsal striatum_1 -> GPe_1 unit_diag.append(1) elif input in range(ds1_len, ds2_len): #50% ds_2 -> GPe_1 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(ds2_len, ds3_len): #0% of ds_3 -> GPe_1 unit_diag.append(0) #GPe_2 elif unit in range(limit_1, limit_2): if input in range(ds1_len): #50% ds_1 -> GPe_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(ds1_len, ds2_len): #75% ds_2 -> GPe_2 if random.randint(4) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(ds2_len, ds3_len): #50% ds_3 -> GPe_2 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) #GPe_3 elif unit in range(limit_2, limit_3): if input in range(ds1_len): #0% ds_1 -> GPe_3 unit_diag.append(0) elif input in range(ds1_len, ds2_len): #50% ds_2 -> GPe_3 if random.randint(2) > 0: unit_diag.append(1) else: unit_diag.append(0) elif input in range(ds2_len, ds3_len): #100% ds_3 -> GPe_3 unit_diag.append(1) self.unit_diags.append(np.array(unit_diag)) self.unit_diags = np.array(self.unit_diags) if use_constraints: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True, constraint=non_neg()) else: self.w = self.add_weight(shape=(self.input_dim, self.units), initializer=w_init, trainable=True) #positive biases self.b = self.add_weight(shape=(self.units, ), initializer=b_init, trainable=True) self.s = tf.convert_to_tensor(np.array([ sparse.diags(self.unit_diags[i], 0).toarray() for i in range(len(self.unit_diags)) ]), dtype=tf.float32)