def GMF(num_users, num_items, latent_dim): # input user_input = Input(shape=(1,), dtype='int32', name='user_input_op') item_input = Input(shape=(1,), dtype='int32', name='item_input_op') # embedding user_embedding = Embedding(input_dim=num_users, output_dim=latent_dim, embeddings_initializer=initializers.random_normal(), input_length=1, name='user_embedding_op')(user_input) item_embedding = Embedding(input_dim=num_items, output_dim=latent_dim, embeddings_initializer=initializers.random_normal(), input_length=1, name='item_embedding_op')(item_input) # flatten user_flatten = Flatten()(user_embedding) item_flatten = Flatten()(item_embedding) # multiply predict_vector = multiply([user_flatten, item_flatten]) # prediction prediction = Dense(1, activation='sigmoid', name='prediction_op')(predict_vector) model_ = Model(inputs=[user_input, item_input], outputs=prediction) return model_
def HourglassNetwork(inpnuts, num_stacks, num_classes, cnv_dim=256, dims=[256, 384, 384, 384, 512]): inter = pre(inpnuts, cnv_dim) outputs = [] for i in range(num_stacks): prev_inter = inter _heads, inter = hourglass_module(num_classes, inter, cnv_dim, i, dims) outputs.append(_heads) if i < num_stacks - 1: inter_ = Conv2D(cnv_dim, 1, use_bias=False, kernel_initializer=random_normal(stddev=0.02), name='inter_.%d.0' % i)(prev_inter) inter_ = BatchNormalization(epsilon=1e-5, name='inter_.%d.1' % i)(inter_) cnv_ = Conv2D(cnv_dim, 1, use_bias=False, kernel_initializer=random_normal(stddev=0.02), name='cnv_.%d.0' % i)(inter) cnv_ = BatchNormalization(epsilon=1e-5, name='cnv_.%d.1' % i)(cnv_) inter = Add(name='inters.%d.inters.add' % i)([inter_, cnv_]) inter = Activation('relu', name='inters.%d.inters.relu' % i)(inter) inter = residual(inter, cnv_dim, 'inters.%d' % i) return outputs
def create_model(): # create model model = Sequential() model.add(Conv2D( 32, (5, 5), input_shape=(32, 32, 3))) # by default it initializes the weights to Xavier model.add(MaxPooling2D((2, 2))) model.add(Dropout(0.2)) model.add(Activation('relu')) model.add(Conv2D( 100, (1, 1))) # by default it initializes the weights to Xavier model.add(Activation('relu')) model.add(Flatten()) model.add( Dense( 1024, kernel_initializer=initializers.random_normal(stddev=0.01))) # 128 model.add(Activation('relu')) model.add( Dense( 256, kernel_initializer=initializers.random_normal(stddev=0.01))) #128 model.add(Activation('relu')) model.add(Dense(43)) model.add(Activation('softmax')) # Compile model model.compile('adam', 'categorical_crossentropy', ['accuracy']) return model
def build_n2n2_AI(LO_weightfile='./n2n2/n2n2_LO.hdf5', K_weightsfile='./n2n2/n2n2_K.hdf5', LO=0, NLO=1): n2n2_LO = Sequential() for i in range(0, 8): n2n2_LO.add( Dense(100, kernel_initializer=initializers.random_normal(mean=0.0, stddev=0.1), input_dim=7)) n2n2_LO.add(Activation('selu')) n2n2_LO.add(Dense(1, kernel_initializer='uniform', activation='linear')) n2n2_LO.compile(optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0), loss='mape') n2n2_LO.load_weights(LO_weightfile) if LO == 1 and NLO == 0: return n2n2_LO if (LO == 1 and NLO == 1) or (LO == 0 and NLO == 1): n2n2_NLO = Sequential() for i in range(0, 8): n2n2_NLO.add( Dense(32, kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.176177), input_dim=6)) n2n2_NLO.add(Activation('selu')) n2n2_NLO.add( Dense(1, kernel_initializer='uniform', activation='linear')) n2n2_NLO.load_weights(K_weightsfile) return n2n2_LO, n2n2_NLO
def get_model(num_users, num_items, latent_dim, regs=[0, 0]): # Input variables user_input = Input(shape=(1,), dtype='int32', name='user_input') item_input = Input(shape=(1,), dtype='int32', name='item_input') # MF_Embedding_User = Embedding(input_dim = num_users, output_dim = latent_dim, name = 'user_embedding', init = init_normal, W_regularizer = l2(regs[0]), input_length=1) MF_Embedding_User = Embedding(input_dim=num_users, output_dim=latent_dim, embeddings_initializer=initializers.random_normal(), embeddings_regularizer=l2(regs[0]), input_length=1, name='user_embedding') # MF_Embedding_Item = Embedding(input_dim = num_items, output_dim = latent_dim, name = 'item_embedding', init = init_normal, W_regularizer = l2(regs[1]), input_length=1) MF_Embedding_Item = Embedding(input_dim=num_items, output_dim=latent_dim, embeddings_initializer=initializers.random_normal(), embeddings_regularizer=l2(regs[1]), input_length=1, name='item_embedding') # Crucial to flatten an embedding vector! user_latent = Flatten()(MF_Embedding_User(user_input)) item_latent = Flatten()(MF_Embedding_Item(item_input)) # Element-wise product of user and item embeddings # predict_vector = merge([user_latent, item_latent], mode = 'mul') predict_vector = multiply([user_latent, item_latent]) # Final prediction layer # prediction = Lambda(lambda x: K.sigmoid(K.sum(x)), output_shape=(1,))(predict_vector) prediction = Dense(1, activation='sigmoid', kernel_initializer=initializers.lecun_normal(), name='prediction')(predict_vector) model_ = Model(input=[user_input, item_input], output=prediction) return model_
def define_nn(self, n_neurons, hidden, m, nb_hidden_layer, learning_rate): classifier = Sequential() if hidden == True: # First Hidden Layer layer0 = Dense(n_neurons, activation='sigmoid', kernel_initializer=initializers.random_normal( stddev=0.03, seed=98765), input_dim=m) classifier.add(layer0) nb = 1 while (nb < nb_hidden_layer): layer_nb = Dense(n_neurons, activation='sigmoid', kernel_initializer=initializers.random_normal( stddev=0.03, seed=98765)) classifier.add(layer_nb) nb += 1 # Output Layer layer1 = Dense(1, activation='sigmoid', kernel_initializer=initializers.random_normal(stddev=0.03, seed=98765), \ kernel_regularizer=regularizers.l2(0.5)) classifier.add(layer1) # Compiling the neural network sgd = optimizers.SGD(lr=learning_rate, clipvalue=0.5) classifier.compile(optimizer=sgd, loss='binary_crossentropy', metrics=['accuracy']) return classifier
def cnn(height, width): question_input = Input(shape=(height, width, 1), name='question_input') conv1_Q = Conv2D(512, (2, 320), activation='sigmoid', padding='valid', kernel_regularizer=regularizers.l2(0.01), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.02))(question_input) Max1_Q = MaxPooling2D((29, 1), strides=(1, 1), padding='valid')(conv1_Q) F1_Q = Flatten()(Max1_Q) Drop1_Q = Dropout(0.25)(F1_Q) predictQ = Dense(32, activation='relu', kernel_regularizer=regularizers.l2(0.01), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.02))(Drop1_Q) prediction2 = Dropout(0.25)(predictQ) predictions = Dense(1, activation='relu')(prediction2) model = Model(inputs=[question_input], outputs=predictions) model.compile(loss='mean_squared_error', optimizer=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)) # model.compile(loss='mean_squared_error', # optimizer='nadam') return model
def identity_block(input_tensor, kernel_size, filters, stage, block): filters1, filters2, filters3 = filters conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = Conv2D(filters1, (1, 1), kernel_initializer=random_normal(stddev=0.02), name=conv_name_base + '2a')(input_tensor) x = BatchNormalization(name=bn_name_base + '2a')(x) x = Activation('relu')(x) x = Conv2D(filters2, kernel_size, padding='same', kernel_initializer=random_normal(stddev=0.02), name=conv_name_base + '2b')(x) x = BatchNormalization(name=bn_name_base + '2b')(x) x = Activation('relu')(x) x = Conv2D(filters3, (1, 1), kernel_initializer=random_normal(stddev=0.02), name=conv_name_base + '2c')(x) x = BatchNormalization(name=bn_name_base + '2c')(x) x = layers.add([x, input_tensor]) x = Activation('relu')(x) return x
def build_model(input_size): input_shape = (input_size[0], input_size[1], 3) model = Sequential() model.add( Conv2D(filters=128, kernel_size=(3, 3), activation='relu', kernel_initializer=initializers.random_normal(mean=0, stddev=0.001), bias_initializer='zeros', padding='same', use_bias=True, input_shape=input_shape)) model.add( Conv2D(filters=64, kernel_size=(5, 5), activation='relu', kernel_initializer=initializers.random_normal(mean=0, stddev=0.001), bias_initializer='zeros', padding='same', use_bias=True)) model.add( Conv2D(filters=3, kernel_size=(3, 3), activation='linear', kernel_initializer=initializers.random_normal(mean=0, stddev=0.001), bias_initializer='zeros', padding='same', use_bias=True)) optimizer = Adam(lr=0.001) # optimizer = SGD(lr=0.01, momentum=0.9) model.compile(optimizer=optimizer, loss='mse') return model
def build(self, input_shape): input_dimension = input_shape[-1] units1 = self.output_dimension * self.number_of_mixtures self.mu_kernel = self.add_weight(name="mu_kernel", shape = shape(input_dimension, units1), initializer=initializers.random_normal(), trainable=True) self.mu_bias = self.add_weight(name="mu_bias", shape = shape(units1), initializer=initializers.zeros(), trainable=True) self.sigma_kernel = self.add_weight(name="sigma_kernel", shape = shape(input_dimension, units1), initializer=initializers.random_normal(), trainable=True) self.sigma_bias = self.add_weight(name="sigma_bias", shape = shape(units1), initializer=initializers.zeros(), trainable=True) units2 = self.number_of_mixtures self.pi_kernel = self.add_weight(name="pi_kernel", shape = shape(input_dimension, units2), initializer=initializers.random_normal(), trainable=True) self.pi_bias = self.add_weight(name="pi_bias", shape = shape(units2), initializer=initializers.zeros(), trainable=True)
def build(self, input_shape, x=None): """ Create a trainable weight variable for this layer. x must be a tensor object input_shape - must have the shape (batch, height, width, channels) according to "channel_last" of Conv2D layer reshape_input_shape - BHW * D Note that the sigma values are saves as std, not as variance""" self.mu = self.add_weight(name='mu', shape=(self.n_clusters, input_shape[-1]), initializer=random_normal(mean=0, stddev=0.4, seed=self.seed), trainable=True) self.std = self.add_weight(name='std', shape=(self.n_clusters, input_shape[-1]), initializer=random_normal(mean=0.3, stddev=0.05, seed=self.seed), trainable=True, constraint=MinValue(min_value=self.epsilon)) self.alpha = self.add_weight( name='alpha', shape=(self.n_clusters, ), initializer=constant(value=(1 / self.n_clusters)), trainable=True) super(GMM, self).build(input_shape)
def __call__(self, ): inp = layers.Input((None, None, self.n_channels)) map_size = tf.shape(inp)[1:3] shared = layers.Conv2D( self.n_channels, 3, activation='relu', padding='SAME', kernel_initializer=initializers.random_normal(stddev=0.01), kernel_regularizer=regularizers.l2(1.0), bias_regularizer=regularizers.l2(2.0))(inp) logits = layers.Conv2D( self.n_anchors * 2, 1, kernel_initializer=initializers.random_normal(stddev=0.01), kernel_regularizer=regularizers.l2(1.0), bias_regularizer=regularizers.l2(2.0))(shared) logits = layers.Reshape((-1, 2))(logits) score = layers.Softmax()(logits) delta = layers.Conv2D( self.n_anchors * 4, 1, kernel_initializer=initializers.random_normal(stddev=0.01), kernel_regularizer=regularizers.l2(1.0), bias_regularizer=regularizers.l2(2.0))(shared) delta = layers.Reshape((-1, 4))(delta) model = models.Model(inp, [logits, delta, score]) return model
def get_rpn(base_layers, num_anchors): #----------------------------------------------------# # 利用一个512通道的3x3卷积进行特征整合 #----------------------------------------------------# x = Conv2D(512, (3, 3), padding='same', activation='relu', kernel_initializer=random_normal(stddev=0.02), name='rpn_conv1')(base_layers) #----------------------------------------------------# # 利用一个1x1卷积调整通道数,获得预测结果 #----------------------------------------------------# x_class = Conv2D(num_anchors, (1, 1), activation='sigmoid', kernel_initializer=random_normal(stddev=0.02), name='rpn_out_class')(x) x_regr = Conv2D(num_anchors * 4, (1, 1), activation='linear', kernel_initializer=random_normal(stddev=0.02), name='rpn_out_regress')(x) x_class = Reshape((-1, 1), name="classification")(x_class) x_regr = Reshape((-1, 4), name="regression")(x_regr) return [x_class, x_regr]
def id2(input_tensor, kernel_size, filters, stage, block, weight_decay, strides): """The identity block is the block that has no conv layer at shortcut. # Arguments input_tensor: input tensor kernel_size: defualt 3, the kernel size of middle conv layer at main path filters: list of integers, the filterss of 3 conv layer at main path stage: integer, current stage label, used for generating layer names block: 'a','b'..., current block label, used for generating layer names # Returns Output tensor for the block. """ #print(input_tensor.shape) kernel_reg = l2(weight_decay[0]) if weight_decay else None bias_reg = l2(weight_decay[1]) if weight_decay else None filters1, filters2, filters3 = filters if K.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = Conv2DTranspose(filters1, (4, 4), strides=strides, padding='same', name=conv_name_base + '2a', kernel_regularizer=kernel_reg, bias_regularizer=bias_reg, kernel_initializer=random_normal(stddev=0.01), bias_initializer=constant(0.0))(input_tensor) #print(x.shape) x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x) x = Activation('relu')(x) x = Conv2D(filters2, kernel_size, padding='same', name=conv_name_base + '2b', kernel_regularizer=kernel_reg, bias_regularizer=bias_reg, kernel_initializer=random_normal(stddev=0.01), bias_initializer=constant(0.0))(x) x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x) x = Activation('relu')(x) x = Conv2D(filters3, kernel_size, padding='same', name=conv_name_base + '2c', kernel_regularizer=kernel_reg, bias_regularizer=bias_reg, kernel_initializer=random_normal(stddev=0.01), bias_initializer=constant(0.0))(x) #x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x) #x = layers.add([x, input_tensor]) #x = Activation('relu')(x) return x
def build_model(shape, gru_layers, reg_layers, drop_layers): # Embedding Layer user_input = Input(shape=(1, ), dtype='int32', name='user_input') item_input = Input(shape=(1, ), dtype='int32', name='item_input') time_input = Input(shape=(1, ), dtype='int32', name='time_input') user_embedding = Flatten()(Embedding( input_dim=shape[0], output_dim=gru_layers[0], embeddings_initializer=initializers.random_normal(), embeddings_regularizer=regularizers.l2(reg_layers[0]), input_length=1, name='gru_user_embedding')(user_input)) item_embedding = Flatten()(Embedding( input_dim=shape[1], output_dim=gru_layers[0], embeddings_initializer=initializers.random_normal(), embeddings_regularizer=regularizers.l2(reg_layers[0]), input_length=1, name='gru_item_embedding')(item_input)) time_embedding = Flatten()(Embedding( input_dim=shape[2], output_dim=gru_layers[1], embeddings_initializer=initializers.random_normal(), embeddings_regularizer=regularizers.l2(reg_layers[0]), input_length=1, name='gru_time_embedding')(time_input)) user_embedding = Dropout(drop_layers[0])(user_embedding) item_embedding = Dropout(drop_layers[0])(item_embedding) time_embedding = Dropout(drop_layers[0])(time_embedding) gru_vector = Concatenate(axis=1)([user_embedding, item_embedding]) gru_vector = Reshape(target_shape=(int(gru_layers[1]), -1))(gru_vector) for index in range(1, len(gru_layers) - 1): layers = GRU(units=gru_layers[index], kernel_initializer=initializers.he_normal(), kernel_regularizer=regularizers.l2(reg_layers[index]), activation='tanh', recurrent_activation='hard_sigmoid', dropout=drop_layers[index], return_sequences=(index != (len(gru_layers) - 2)), name='gru_layer_%d' % index) gru_vector = layers([gru_vector, time_embedding]) gru_vector = Dropout(drop_layers[-1])(gru_vector) prediction = Dense(units=gru_layers[-1], activation='relu', kernel_initializer=initializers.lecun_normal(), kernel_regularizer=regularizers.l2(reg_layers[-1]), name='gru_prediction')(gru_vector) _model = Model(inputs=[user_input, item_input, time_input], outputs=prediction) return _model
def residual_block(self, input_layer, num_ch, name): x = layers.Conv2D(num_ch, (3,3), padding = 'same', kernel_initializer=initializers.random_normal(stddev=0.01), name = (name + "Conv2D_1"))(input_layer) x = layers.Conv2D(num_ch, (3,3), padding = 'same', kernel_initializer=initializers.random_normal(stddev=0.01), name = (name + "Conv2D_2"))(x) x = layers.add([x, input_layer]) x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) return (x)
def GenerateModel(self): gf_dim = 64 gan = Sequential() gan.add( Dense(8192, use_bias=True, bias_initializer='zeros', input_dim=100)) gan.add(Reshape([4, 4, gf_dim * 8])) gan.add(BatchNormalization(epsilon=1e-5, momentum=0.9, scale=True)) gan.add(Activation('relu')) gan.add( Conv2DTranspose( gf_dim * 4, 5, strides=(2, 2), padding='same', use_bias=True, kernel_initializer=initializers.random_normal(stddev=0.02), bias_initializer='zeros') ) #see in channel value and std_value for random normal gan.add(BatchNormalization(epsilon=1e-5, momentum=0.9, scale=True)) gan.add(Activation('relu')) gan.add( Conv2DTranspose( gf_dim * 2, 5, strides=(2, 2), padding='same', use_bias=True, kernel_initializer=initializers.random_normal(stddev=0.02), bias_initializer='zeros') ) #see in channel value and std_value for random normal gan.add(BatchNormalization(epsilon=1e-5, momentum=0.9, scale=True)) gan.add(Activation('relu')) gan.add( Conv2DTranspose( gf_dim * 1, 5, strides=(2, 2), padding='same', use_bias=True, kernel_initializer=initializers.random_normal(stddev=0.02), bias_initializer='zeros') ) #see in channel value and std_value for random normal gan.add(BatchNormalization(epsilon=1e-5, momentum=0.9, scale=True)) gan.add(Activation('relu')) gan.add( Conv2DTranspose( 3, 5, strides=(2, 2), padding='same', use_bias=True, kernel_initializer=initializers.random_normal(stddev=0.02), bias_initializer='zeros') ) #see in channel value and std_value for random normal gan.add(Activation('tanh')) self.GAN = gan
def residual_block_first(self,input_layer, num_ch, name): x = layers.Conv2D(num_ch, (3,3), padding = 'same', kernel_initializer=initializers.random_normal(stddev=0.01), name = (name + "_Conv2D_1"))(input_layer) shortcut = layers.MaxPooling2D((2,2), name = (name + "_maxpooling"))(x) x = layers.Conv2D(num_ch, (3,3), padding = 'same', kernel_initializer=initializers.random_normal(stddev=0.01), name = (name + "_Conv2D_2"))(shortcut) x = layers.add([x, shortcut]) x = layers.BatchNormalization()(x) x = layers.Activation('relu')(x) return (x)
def MImodel(train_data,label_data,val_data1,val_data2): model = Sequential() model.add(layers.Dense(8,activation='relu', kernel_initializer=initializers.random_normal(seed=1),bias_initializer=initializers.random_normal(seed=2))) #model.add(layers.Dense(4,activation='relu')) model.add(layers.Dense(1,activation='sigmoid', kernel_initializer=initializers.random_normal(seed=3),bias_initializer=initializers.random_normal(seed=4))) model.compile(optimizer='Adam',loss='mse',metrics=['acc']) history = model.fit(train_data, label_data,validation_data=(val_data1,val_data2),epochs=50,batch_size=32) miloss = history.history['loss'] return miloss
def clear_memory(self, goal): self.learning_done = True ## Set the done learning flag #del self.trainable_model del self.memory self.memory = PrioritizedReplayBuffer(self.controllerMemCap, alpha=prioritized_replay_alpha) gpu = self.net.gpu device = '/cpu' if gpu < 0 else '/gpu:' + str(gpu) #del self.net gc.collect() rmsProp = optimizers.RMSprop(lr=LEARNING_RATE, rho=0.95, epsilon=1e-08, decay=0.0) with tf.device(device): self.simple_net = Sequential() self.simple_net.add( Conv2D(32, (8, 8), strides=4, activation='relu', padding='valid', input_shape=(84, 84, 4))) self.simple_net.add( Conv2D(64, (4, 4), strides=2, activation='relu', padding='valid')) self.simple_net.add( Conv2D(64, (3, 3), strides=1, activation='relu', padding='valid')) self.simple_net.add(Flatten()) self.simple_net.add( Dense(HIDDEN_NODES, activation='relu', kernel_initializer=initializers.random_normal( stddev=0.01, seed=SEED))) self.simple_net.add( Dense(nb_Action, activation='linear', kernel_initializer=initializers.random_normal( stddev=0.01, seed=SEED))) self.simple_net.compile(loss='mse', optimizer=rmsProp) self.simple_net.load_weights(recordFolder + '/policy_subgoal_' + str(goal) + '.h5') self.simple_net.reset_states()
def QNET(self, name = None): input_shape = (self.config.VISUAL_DESCRIPTOR + self.config.ACTIONS*self.config.HIS_STEPS,) input_tensor = KL.Input(shape = input_shape, name = name + '_Q_input') x = KL.Dense(1024, activation = 'relu', kernel_initializer=random_normal(stddev=0.01), name = name + '_Dense_1')(input_tensor) x = KL.Dropout(0.2)(x) x = KL.Dense(1024, activation = 'relu', kernel_initializer=random_normal(stddev=0.01), name = name + '_Dense_2')(x) x = KL.Dropout(0.2)(x) x = KL.Dense(self.config.ACTIONS, activation = 'linear', kernel_initializer=random_normal(stddev=0.01), name = name + '_Action')(x) return KM.Model(inputs = input_tensor, outputs = x, name = name + '_QNET')
def fit_model(X, y): # design network model = Sequential() model.add(Dense(10, input_dim=1, kernel_initializer=random_normal(seed=1))) model.add(Dense(1, kernel_initializer=random_normal(seed=1))) model.compile(loss='mean_squared_error', optimizer='adam') # fit network model.fit(X, y, epochs=100, batch_size=len(X), verbose=0) # forecast yhat = model.predict(X, verbose=0) print(mean_squared_error(y, yhat[:, 0]))
def cnn(height_a, height_q, count): question_input = Input(shape=(height_q, 1), name='question_input') embedding_q = Embedding(input_dim=count, output_dim=128, input_length=height_q)(question_input) re_q = Reshape((height_q, 128, 1), input_shape=(height_q, ))(embedding_q) conv1_Q = Conv2D(128, (2, 128), activation='sigmoid', padding='valid', kernel_regularizer=regularizers.l2(0.02), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.05))(re_q) Max1_Q = MaxPooling2D((29, 1), strides=(1, 1), padding='valid')(conv1_Q) F1_Q = Flatten()(Max1_Q) Drop1_Q = Dropout(0.5)(F1_Q) predictQ = Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.02), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.05))(Drop1_Q) # kernel_initializer=initializers.random_normal(mean=0.0, stddev=0.01) answer_input = Input(shape=(height_a, 1), name='answer_input') embedding_a = Embedding(input_dim=count, output_dim=128, input_length=height_a)(answer_input) re_a = Reshape((height_a, 128, 1), input_shape=(height_a, ))(embedding_a) conv1_A = Conv2D(128, (2, 128), activation='sigmoid', padding='valid', kernel_regularizer=regularizers.l2(0.02), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.05))(re_a) Max1_A = MaxPooling2D((399, 1), strides=(1, 1), padding='valid')(conv1_A) F1_A = Flatten()(Max1_A) Drop1_A = Dropout(0.5)(F1_A) predictA = Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.02), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.05))(Drop1_A) predictions = merge([predictA, predictQ], mode='dot') model = Model(inputs=[question_input, answer_input], outputs=predictions) model.compile(loss='mean_squared_error', optimizer=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)) # model.compile(loss='mean_squared_error', # optimizer='nadam') return model
def train(data, param): """ 对输入神经网络的数据进行训练和评估 :param data: 输入训练和测试数据 :param param: 网络配置的参数 :return: 返回神经网络的测试数据集表现 """ from keras.layers import Dense, Flatten, BatchNormalization, Activation, Dropout from keras.layers.convolutional import Conv2D, MaxPooling2D from keras.models import Sequential from keras import initializers from keras import regularizers x_train, x_test, y_train, y_test = data x_train = x_train.reshape((-1, param.loop_num, param.time_intervals, 1)) y_train = y_train.reshape(-1, 1) x_test = x_test.reshape((-1, param.loop_num, param.time_intervals, 1)) y_test = y_test.reshape(-1, 1) # def mape_error(y_true, y_pred): # return K.mean(K.abs(y_pred - y_true)/y_true, axis=-1) # model=load_model('E:/LeNet/LeNet-5_model.h5') # convolution 1st layer model = Sequential() model.add(Conv2D(16, (3, 3), strides=(1, 1), input_shape=(param.loop_num, param.time_intervals, 1), padding='same', activation='relu', kernel_initializer=initializers.random_normal(stddev=0.1))) model.add(MaxPooling2D(pool_size=(2, 2))) # convolution 2nd layer model.add(Conv2D(32, (3, 3), strides=(1, 1), padding='same', activation='relu', kernel_initializer=initializers.random_normal(stddev=0.1))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(32, activation='relu', kernel_regularizer=regularizers.l2(param.regularization))) model.add(Dense(16, activation='relu', kernel_regularizer=regularizers.l2(param.regularization))) model.add(Dense(1)) model.compile(optimizer='adam', loss='mean_absolute_percentage_error', metrics=['mean_absolute_percentage_error', 'mean_absolute_error']) model.summary() history = LossHistory() early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=param.early_stop_epochs, mode='min') reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', # 监控模型的验证损失 factor=0.5, # 触发时将学习率除以5 patience=param.reduce_lr_epochs) model.fit(x_train, y_train, batch_size=param.batch_size, epochs=param.epochs, shuffle=True, validation_split=0.2, callbacks=[history, early_stop, reduce_lr], verbose=0) loss, mape, mae = model.evaluate(x_test, y_test, verbose=0) # model.save(os.path.join(param.file_path, 'model\\', # 'model_ST={}_{}_mape={mape:.3f}_mae={mae:.3f}_time_lag{time}.h5'.format( # param.loop_num, param.time_intervals, mape=mape, mae=mae, # time=((1+param.predict_intervals)*5)))) # history.loss_plot('epoch', param) return [mape, mae]
def Attmodel(train_data,label_data,val_data1,val_data2): model = Sequential() model.add(You.AttentionLayer_2D(supmask=False)) model.add(layers.Dense(8,activation='relu', kernel_initializer=initializers.random_normal(seed=1),bias_initializer=initializers.random_normal(seed=2))) #model.add(layers.Dense(4,activation='relu')) model.add(layers.Dense(1,activation='sigmoid', kernel_initializer=initializers.random_normal(seed=3),bias_initializer=initializers.random_normal(seed=4))) model.compile(optimizer='Adam',loss='mse',metrics=['acc']) history = model.fit(train_data, label_data,validation_data=(val_data1,val_data2),epochs=100,batch_size=32) adloss = history.history['loss'] advalacc=history.history['val_acc'] model.summary() return adloss, advalacc
def centernet_head(x, num_classes): x = Dropout(rate=0.5)(x) #-------------------------------# # 解码器 #-------------------------------# num_filters = 256 # 16, 16, 2048 -> 32, 32, 256 -> 64, 64, 128 -> 128, 128, 64 for i in range(3): # 进行上采样 x = Conv2DTranspose(num_filters // pow(2, i), (4, 4), strides=2, use_bias=False, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(5e-4))(x) x = BatchNormalization()(x) x = Activation('relu')(x) # 最终获得128,128,64的特征层 # hm header y1 = Conv2D(64, 3, padding='same', use_bias=False, kernel_initializer=random_normal(stddev=0.02))(x) y1 = BatchNormalization()(y1) y1 = Activation('relu')(y1) y1 = Conv2D(num_classes, 1, kernel_initializer=constant(0), bias_initializer=constant(-2.19), activation='sigmoid')(y1) # wh header y2 = Conv2D(64, 3, padding='same', use_bias=False, kernel_initializer=random_normal(stddev=0.02))(x) y2 = BatchNormalization()(y2) y2 = Activation('relu')(y2) y2 = Conv2D(2, 1, kernel_initializer=random_normal(stddev=0.02))(y2) # reg header y3 = Conv2D(64, 3, padding='same', use_bias=False, kernel_initializer=random_normal(stddev=0.02))(x) y3 = BatchNormalization()(y3) y3 = Activation('relu')(y3) y3 = Conv2D(2, 1, kernel_initializer=random_normal(stddev=0.02))(y3) return y1, y2, y3
def create_model(): classifier = Sequential() # Adding a first convolutional layer classifier.add( Conv2D(16, (5, 5), input_shape=(80, 80, 3), activation='relu', kernel_initializer=initializers.random_normal(stddev=0.04, mean=0.00), bias_initializer=initializers.Constant(value=0.2))) classifier.add(MaxPooling2D(pool_size=(2, 2))) # Adding a second convolutional layer classifier.add( Conv2D(32, (5, 5), activation='relu', kernel_initializer=initializers.random_normal(stddev=0.04, mean=0.00), bias_initializer=initializers.Constant(value=0.2))) classifier.add(MaxPooling2D(pool_size=(2, 2))) # Adding a third convolutional layer classifier.add( Conv2D(48, (4, 4), activation='relu', kernel_initializer=initializers.random_normal(stddev=0.04, mean=0.00), bias_initializer=initializers.Constant(value=0.2))) classifier.add(MaxPooling2D(pool_size=(2, 2))) # Flattening classifier.add(Flatten()) #Full connection classifier.add( Dense(512, activation='relu', kernel_initializer=initializers.random_normal(stddev=0.02, mean=0.00), bias_initializer=initializers.Constant(value=0.1))) # output layer classifier.add( Dense(11, activation='softmax', kernel_initializer=initializers.random_normal(stddev=0.02, mean=0.00), bias_initializer=initializers.Constant(value=0.1))) return classifier
def cnn(height_a, height_q, width_a, width_q, extra_len): question_input = Input(shape=(height_q, width_q, 1), name='question_input') conv1_Q = Conv2D(512, (2, 128), activation='sigmoid', padding='valid', kernel_regularizer=regularizers.l2(0.01), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.01))(question_input) Max1_Q = MaxPooling2D((29, 1), strides=(1, 1), padding='valid')(conv1_Q) F1_Q = Flatten()(Max1_Q) Drop1_Q = Dropout(0.5)(F1_Q) predictQ = Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.01), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.01))(Drop1_Q) # kernel_initializer=initializers.random_normal(mean=0.0, stddev=0.01) answer_input = Input(shape=(height_a, width_a, 1), name='answer_input') conv1_A = Conv2D(512, (2, 128), activation='sigmoid', padding='valid', kernel_regularizer=regularizers.l2(0.01), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.01))(answer_input) Max1_A = MaxPooling2D((319, 1), strides=(1, 1), padding='valid')(conv1_A) F1_A = Flatten()(Max1_A) Drop1_A = Dropout(0.5)(F1_A) predictA = Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.01), kernel_initializer=initializers.random_normal( mean=0.0, stddev=0.01))(Drop1_A) extra_input = Input(shape=(extra_len, ), name='extra_input') predictQ1 = concatenate([predictQ, extra_input], axis=1) predictA1 = concatenate([predictA, extra_input], axis=1) predictions = merge([predictA1, predictQ1], mode='dot') model = Model(inputs=[question_input, answer_input, extra_input], outputs=predictions) model.compile(loss='mean_squared_error', optimizer=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)) # model.compile(loss='mean_squared_error', # optimizer='nadam') return model
def _create_model(self): input_x = Input(shape=(self.n_features, )) x = Dense(10, kernel_initializer=initializers.random_normal(stddev=0.3), bias_initializer=initializers.Constant(0.1), activation='relu')(input_x) predictions = Dense( self.n_actions, kernel_initializer=initializers.random_normal(stddev=0.3), bias_initializer=initializers.Constant(0.1))(x) model = Model(inputs=input_x, outputs=predictions) model.compile(optimizer=optimizers.RMSprop(lr=self.lr), loss='mean_squared_error') return model
def get_model(c, n1, n2, f1, f2, f3, fsub): input = Input(shape=(fsub, fsub, c)) x = Conv2D(filters=n1, kernel_size=f1, activation='relu', kernel_initializer=random_normal(stddev=1e-3))(input) x = Conv2D(filters=n2, kernel_size=f2, activation='relu', kernel_initializer=random_normal(stddev=1e-3))(x) x = Conv2D(filters=c, kernel_size=f3, activation='relu', kernel_initializer=random_normal(stddev=1e-3))(x) return Model(inputs=input, outputs=x)
def __init__(self, weights_path, train_conv_layers): self.__angle_values = [-1, -0.5, 0, 0.5, 1] self.__nb_actions = 5 self.__gamma = 0.99 #Define the model activation = 'relu' pic_input = Input(shape=(59,255,3)) img_stack = Conv2D(16, (3, 3), name='convolution0', padding='same', activation=activation, trainable=train_conv_layers)(pic_input) img_stack = MaxPooling2D(pool_size=(2,2))(img_stack) img_stack = Conv2D(32, (3, 3), activation=activation, padding='same', name='convolution1', trainable=train_conv_layers)(img_stack) img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack) img_stack = Conv2D(32, (3, 3), activation=activation, padding='same', name='convolution2', trainable=train_conv_layers)(img_stack) img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack) img_stack = Flatten()(img_stack) img_stack = Dropout(0.2)(img_stack) img_stack = Dense(128, name='rl_dense', kernel_initializer=random_normal(stddev=0.01))(img_stack) img_stack=Dropout(0.2)(img_stack) output = Dense(self.__nb_actions, name='rl_output', kernel_initializer=random_normal(stddev=0.01))(img_stack) opt = Adam() self.__action_model = Model(inputs=[pic_input], outputs=output) self.__action_model.compile(optimizer=opt, loss='mean_squared_error') self.__action_model.summary() # If we are using pretrained weights for the conv layers, load them and verify the first layer. if (weights_path is not None and len(weights_path) > 0): print('Loading weights from my_model_weights.h5...') print('Current working dir is {0}'.format(os.getcwd())) self.__action_model.load_weights(weights_path, by_name=True) print('First layer: ') w = np.array(self.__action_model.get_weights()[0]) print(w) else: print('Not loading weights') # Set up the target model. # This is a trick that will allow the model to converge more rapidly. self.__action_context = tf.get_default_graph() self.__target_model = clone_model(self.__action_model) self.__target_context = tf.get_default_graph() self.__model_lock = threading.Lock()
def __init__(self, initial_batch_size, units, num_blocks, num_units_per_block, vocab_size, keys, activation, weights=None, initializer='normal', bias_initializer='zeros', use_bias=True, **kwargs): super(REN, self).__init__(**kwargs) self.units = units self._num_blocks = num_blocks self._num_units_per_block = num_units_per_block self._vocab_size = vocab_size self._keys = keys self._activation = activation # self._activation = activation # if activation == 'prelu': # self._activation = prelu # else: # self._activation = activations.get(activation) self._initializer = initializers.random_normal(stddev=0.1) # self.ortho_initializer = tf.orthogonal_initializer(gain=1.0) self.initial_batch_size = initial_batch_size self.bias_initializer = initializers.get(bias_initializer) self.supports_masking = True self.use_bias = use_bias self.initial_weights = weights
def conv(x, nf, ks, name, weight_decay): kernel_reg = l2(weight_decay[0]) if weight_decay else None bias_reg = l2(weight_decay[1]) if weight_decay else None x = Conv2D(nf, (ks, ks), padding='same', name=name, kernel_regularizer=kernel_reg, bias_regularizer=bias_reg, kernel_initializer=random_normal(stddev=0.01), bias_initializer=constant(0.0))(x) return x