def getScalingDenseLayer(input_location, input_scale): recip_input_scale = np.reciprocal(input_scale) waux = np.diag(recip_input_scale) baux = -input_location*recip_input_scale dL = Dense(input_location.shape[0], activation = None, input_shape = input_location.shape) dL.build(input_shape = input_location.shape) dL.set_weights([waux, baux]) dL.trainable = False return dL
def inputsSelection(inputs_shape, ndex): if not hasattr(ndex,'index'): ndex = list(ndex) input_mask = np.zeros([inputs_shape[-1], len(ndex)]) for i in range(inputs_shape[-1]): for v in ndex: if i == v: input_mask[i,ndex.index(v)] = 1 dL = Dense(len(ndex), activation = None, input_shape = inputs_shape, use_bias = False) dL.build(input_shape = inputs_shape) dL.set_weights([input_mask]) dL.trainable = False return dL
def get_sparse_mlp(ws, bs, ls, reference): """ :param ws: Weights of the MLP (as a list) :param bs: Biases of the MLP (as a list) :param ls: link functions :param reference: baselines (aka reference points) :return: (keras) sparse version of the model """ # New MLP number of neurons times = np.ones(len(ls)).astype(np.int) for j in range(len(ls) - 2, -1, -1): times[j] = np.size(ws[j], 1) * times[j + 1] # build sparse model sparse_model = Sequential() for j in range(len(ls)): # Need to store dimensions in some scalar n_neurons_realnet = np.size(ws[j], 0) # Initialize Weight vector to 0s this_w = np.zeros((n_neurons_realnet * times[j], times[j])) # and biases this_b = np.zeros(times[j]) # Fill the biases and the weights in the correct place col = 0 for i in range(np.size(this_w, 1)): if col == np.size(ws[j], 1): col = 0 this_w[i * n_neurons_realnet:(i + 1) * n_neurons_realnet, i] = ws[j][:, col] this_b[i] = np.asarray(bs[j])[col] col += 1 # Add layer to the network this_dense = Dense(units=np.size(this_w, 1), activation=ls[j], input_shape=(np.size(this_w, 0), )) sparse_model.add(this_dense) this_dense.set_weights([this_w, this_b]) # compile the new (sparse) model opt = keras.optimizers.Adam() sparse_model.compile(loss=keras.losses.binary_crossentropy, optimizer=opt, metrics=['accuracy']) # Print reference at_reference = sparse_model.predict(np.array(reference).reshape(1, -1)) print("Prediction at the reference point is: ", at_reference) return sparse_model
#decoder de_input = Input(shape=(1, fr_se_vocab)) de_state_in = Input(shape=(hsize, )) #---> = result from encoder.predict #decoder's interim layers de_gru = GRU(hsize, return_state=True) de_out, de_state_out = de_gru(de_input, initial_state=de_state_in) de_dense = Dense(fr_se_vocab, activation='softmax') de_pred = de_dense(de_out) decoder = Model(inputs=[de_input, de_state_in], outputs=[de_pred, de_state_out]) #set weights from teacher-forcing model en_gru.set_weights(model_weights.en_gru_weight()) de_gru.set_weights(model_weights.de_gru_weight()) de_dense.set_weights(model_weights.de_dense_weight()) ################################################### #function to translate english to french def translate_to_french(english_sentence): #convert english sentence to one hot en_sent_oh = sent2oh(english_sentence, language='en', reverse=True) #convert word 'sos' to oh de_w_seq = word2oh('sos', language='fr', se=True) de_w_seq = de_w_seq.reshape(1, 1, fr_se_vocab) #get the en_state from result in encoder de_state = encoder.predict(en_sent_oh) fr_sent = ''