def mlp_model(x_train, y_train, x_val, y_val, params): model = Sequential() model.add( Dense(params['layer_size'], activation=params['activation'], input_dim=x_train.shape[1], kernel_regularizer=l2(params['regularization']))) model.add(Dropout(params['dropout'])) for i in range(params['layers'] - 1): model.add( Dense(params['layer_size'], activation=params['activation'], kernel_regularizer=l2(params['regularization']))) model.add(Dropout(params['dropout'])) model.add(Dense(2, activation='softmax')) model.compile( optimizer=params['optimizer'](params['lr']), loss=params['loss_functions'], # loss=params['loss_functions']([params['weights1'], params['weights2']]), metrics=['accuracy', Recall(), Precision(), f1]) history = model.fit(x_train, y_train, batch_size=params['batch_size'], validation_data=(x_val, y_val), epochs=100, callbacks=[ EarlyStopping(monitor='val_acc', patience=5, min_delta=0.01) ], verbose=0) return history, model
def build(width, height, depth, classes): # initialize the model along with the input shape to be # "channels last" model = Sequential() #the image input inputShape = (height, width, depth) # if we are using "channels first", update the input shape if image_data_format() == "channels_first": inputShape = (depth, height, width) #Every CNN that you implement will have a build method this function will accept a #number of parameters, construct the network architecture, and then return it to the calling function #It will accept a number of parameters #define the first (and only) CONV=>RELU layer #This layer will have 32 filters each of which are 3x3, apply the asame padding #to ensure the size of the output of the convolution operations matches the input #(using same padding isn't strictly neccessary for this example, but it's a good) #habbit to start forming now model.add(Conv2D(32,(3,3),padding="same")) model.add(Activation("relu")) #softmax classifier model.add(Flatten()) model.add(Dense(classes)) model.add(Activation("softmax")) #return the constructed network architechture return model
def define_gan(self): self.discriminator.trainable = False model = Sequential() model.add(self.generator) model.add(self.discriminator) model.compile(loss='binary_crossentropy', optimizer='adam') return model
def create_model(): model = Sequential() model.add(Dense(1, input_shape=(3, ), activation='sigmoid')) # model.add(Dense(NUMBER_OF_ACTIONS, activation='sigmoid')) sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss="mse", optimizer=sgd, metrics=["accuracy"]) return model
def _define_composite(generators, discriminators): model_list = [] for i in range(len(discriminators)): g_models, d_models = generators[i], discriminators[i] # straight-through model d_models[0].trainable = False model1 = Sequential() model1.add(g_models[0]) model1.add(d_models[0]) model1.compile(loss=wasserstein_loss, optimizer=Adam(lr=0.001, beta_1=0, beta_2=0.99, epsilon=10e-8)) # fade-in model d_models[1].trainable = False model2 = Sequential() model2.add(g_models[1]) model2.add(d_models[1]) model2.compile(loss=wasserstein_loss, optimizer=Adam(lr=0.001, beta_1=0, beta_2=0.99, epsilon=10e-8)) # store model_list.append([model1, model2]) return model_list
def make_model(input_shape): ret = Sequential() ret.add(Dense(10, input_shape=input_shape, activation='sigmoid')) # ret.add(Dense(3, input_shape=input_shape, activation='sigmoid')) # ret.add(Dense(3, activation='relu')) ret.add(Dense(1, activation='linear')) return ret
def build_nn_model(input_shape, nn_define, loss, optimizer, metrics, is_supported_layer=has_builder, default_layer=None) -> KerasNNModel: model = Sequential() is_first_layer = True for layer_config in nn_define: layer = layer_config.get("layer", default_layer) if layer and is_supported_layer(layer): del layer_config["layer"] if is_first_layer: layer_config["input_shape"] = input_shape is_first_layer = False builder = get_builder(layer) model.add(builder(**layer_config)) else: raise ValueError(f"dnn not support layer {layer}") return from_keras_sequential_model(model=model, loss=loss, optimizer=optimizer, metrics=metrics)
def build_gru_model(): model = Sequential() #CuDNNGRU 代替GRU, 提高速度 model.add(CuDNNGRU(32, input_shape=(None, float_data.shape[-1]))) model.add(Dense(1)) model.compile(optimizer=RMSprop(), loss='mae') return model
class PPOValueBrain: def __init__( self, learning_rate: float = 0.0001, hidden_layers_count: int = 0, neurons_per_hidden_layer: int = 0, ): self.model = Sequential() for i in range(hidden_layers_count): self.model.add(Dense(neurons_per_hidden_layer, activation=tanh)) self.model.add(Dense(1, activation=linear, use_bias=True)) self.model.compile(loss=mse, optimizer=Adam(lr=learning_rate)) def predict(self, state: np.ndarray) -> np.ndarray: return self.model.predict(np.array((state,)))[0] def train(self, states: np.ndarray, targets: np.ndarray): self.model.train_on_batch(states, targets) def save_model(self, filename: str): self.model.save(f"{filename}_critic.h5") def load_model(self, filename: str): self.model = load_model(filename)
def upsample(units, input_shape=None, apply_dropout=False, layer_type='dense', output_padding=(1, 1)): initializer = random_normal_initializer(0., 0.02) seq = Sequential() if layer_type == 'dense': seq.add( layers.Dense(units, input_shape=[ input_shape, ], kernel_initializer=initializer, use_bias=False)) elif layer_type == 'conv': seq.add( layers.Conv2DTranspose(filters=units, kernel_size=3, strides=(2, 2), padding='same', input_shape=input_shape, kernel_initializer=initializer, use_bias=False, output_padding=output_padding)) else: raise ValueError('wrong layer_type!') seq.add(layers.BatchNormalization()) if apply_dropout: seq.add(layers.Dropout(0.5)) seq.add(layers.ReLU()) return seq
def build_model(layers): model = Sequential() for layer in layers: model.add(layer) model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"]) return model
def build_resblock(self, filter_num, blocks, stride=1): res_blocks = Sequential() # may down sample res_blocks.add(Basic_Block(filter_num, stride)) # do not down sample for _ in range(1, blocks): res_blocks.add(Basic_Block(filter_num, stride=1)) return res_blocks
def build_resblock(self, filter_num, blocks, stride=1): res_blocks = Sequential() # may down sample 也许进行下采样。 # 对于当前Res Block中的Basic Block,我们要求每个Res Block只有一次下采样的能力。 res_blocks.add(BasicBlock(filter_num, stride)) for _ in range(1, blocks): res_blocks.add(BasicBlock(filter_num, stride=1)) return res_blocks
class Discriminator(Model): def __init__(self, num_layer: int, num_cat: int): super().__init__() self.num_layer = num_layer self.num_cat = num_cat def build(self, input_shape): kernel_size = 5 stride_size = 2 width = input_shape[2] height = input_shape[1] num_channel = input_shape[3] next_channel = num_channel * 32 kernel_init = keras.initializers.RandomNormal(stddev=0.02) bias_init = keras.initializers.zeros() self.conv2ds = Sequential() for i in range(self.num_layer - 1): conv = Conv2D(next_channel, kernel_size, stride_size, padding="same", activation=tf.nn.leaky_relu, kernel_initializer=kernel_init, bias_initializer=bias_init, input_shape=(height, width, num_channel)) self.conv2ds.add(conv) width = conv.output_shape[2] height = conv.output_shape[1] num_channel = next_channel next_channel *= stride_size conv = Conv2D(1 + self.num_cat, (height, width), (height, width), padding="valid", kernel_initializer=kernel_init, bias_initializer=bias_init) self.conv2ds.add(conv) self.flatten = Flatten() def call(self, inputs: keras.layers.Input, **kwargs): output = inputs output = self.conv2ds(output) output = self.flatten(output) classify_result: tf.Tensor = output[:, :1] cat_result: tf.Tensor = output[:, 1:] return classify_result, cat_result
def create_model(num_frame, num_joint, num_output): model = Sequential() model.add( CuDNNLSTM(50, input_shape=(num_frame, num_joint), return_sequences=False)) model.add(Dropout(0.4)) #使用Dropout函数可以使模型有更多的机会学习到多种独立的表征 model.add(Dense(60)) model.add(Dropout(0.4)) model.add(Dense(num_output, activation='softmax')) return model
def fit_mlp(x_train, y_train, conf, seed=3, epochs=1500, batch_size=300, lr=0.05): """ :param x_train: training data :param y_train: training target :param conf: model structure :param seed: seed :param epochs: number of epochs (using early stopping) :param batch_size: batch size :param lr: learning rate :return: model and history """ early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=0, patience=3, restore_best_weights=True) model = Sequential() for n, a in conf: model.add( Dense( n, activation=a, kernel_initializer=keras.initializers.glorot_normal(seed=seed), bias_initializer='zeros')) opt = keras.optimizers.Adam(lr=lr) if conf[-1][1] == 'linear': model.compile(loss=keras.losses.mse, optimizer=opt) elif conf[-1][1] == 'sigmoid': model.compile(loss=keras.losses.binary_crossentropy, optimizer=opt, metrics=['accuracy']) else: model.compile(loss=keras.losses.sparse_categorical_crossentropy, optimizer=opt, metrics=['accuracy']) history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.2, verbose=0, shuffle=False, callbacks=[early_stop]) return model, history
def define_generator(self): model = Sequential() model.add( Dense(128, activation='relu', kernel_initializer='he_uniform', input_dim=self.latent_dim)) model.add(BatchNormalization()) model.add(Dense(256, activation='relu')) model.add(BatchNormalization()) model.add(Dense(self.n_outputs, activation='linear')) return model
def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units): model = Sequential() model.add( Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True)) model.add(LSTM(n_units)) model.add(RepeatVector(tar_timesteps)) model.add(LSTM(n_units, return_sequences=True)) model.add(TimeDistributed(Dense(tar_vocab, activation='softmax'))) return model
def gru_test(): ''' 使用return_sequences 返回所有time steps的输出 不适用的时候只返回最后一次 ''' model = Sequential() model.add(CuDNNGRU(128)) # model.add(CuDNNGRU(128, return_sequences=True)) model.compile('rmsprop', 'mse') input_array = np.random.normal(size=(32, 10, 1)) output_array = model.predict(input_array) print(output_array.shape) return model
class PointwiseNN(Ranker): def __init__(self): self.model = Sequential() self.model.add(Dense(128)) self.model.add(Dense(1)) self.model.compile(optimizer='adam', loss='mse') super().__init__() def fit(self, X_train, y_train): self.model.fit(x=X_train, y=y_train) def predict(self, X) -> ndarray: return self.model.predict(x=X)
def make_cnn(filters, kernels, strides, activation='tanh', reg=1e-6, flat=False): _reg = l2(reg) cnn = Sequential([ Conv2D(f, k, s, activation=activation, kernel_regularizer=_reg) for f, k, s in zip(filters, kernels, strides) ]) if flat: cnn.add(Flatten()) return cnn
def get_bidirectional_model(self, pre_embeddings, dp_rate=0.0, use_lstm=False): """ follow the common model construction step shown in keras manual :param pre_embeddings: :param dp_rate: drop out rate :param use_lstm: utilize LSTM or GRU unit :return: the model """ # Embedding part can try multichannel as same as origin paper embedding_layer = Embedding(self.max_features, # 字典长度 self.embedding_dims, # 词向量维度 weights=[pre_embeddings], # 预训练的词向量 input_length=self.maxlen, # 每句话的最大长度 trainable=False # 是否在训练过程中更新词向量 ) model = Sequential() model.add(embedding_layer) if use_lstm: model.add(Bidirectional(LSTM(RNN_DIM, recurrent_dropout=dp_rate))) else: model.add(Bidirectional(GRU(RNN_DIM, recurrent_dropout=dp_rate))) # model.add(Dropout(dp_rate)) model.add(Dense(self.class_num, activation=self.last_activation)) return model
def downsample(units, input_shape=None, apply_batchnorm=True, layer_type='dense'): initializer = random_normal_initializer(0., 0.02) seq = Sequential() if layer_type == 'dense': seq.add( layers.Dense(units, input_shape=[ input_shape, ], kernel_initializer=initializer, use_bias=False)) elif layer_type == 'conv': seq.add( layers.Conv2D(filters=units, kernel_size=3, strides=(2, 2), padding='same', input_shape=input_shape, kernel_initializer=initializer, use_bias=False)) else: raise ValueError('wrong layer type!') if apply_batchnorm: seq.add(layers.BatchNormalization()) seq.add(layers.LeakyReLU()) return seq
class BiLSTM(NNBaseModel): def train(self): batch_size = 64 units = 100 embedding_matrix = np.zeros((self.vocab_size, 100)) for word, index in self.tk.word_index.items(): embedding_vector = self.word2vec.get(word) if embedding_vector is not None: embedding_matrix[index] = embedding_vector self.model = Sequential() self.model.add( Embedding(self.vocab_size, units, weights=[embedding_matrix], trainable=False)) self.model.add( Bidirectional(LSTM(units, return_sequences=True, dropout=0.2))) self.model.add(Bidirectional(LSTM(units, dropout=0.2))) self.model.add(Dense(self.output_size, activation='sigmoid')) print(self.model.summary()) self.model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc']) history = self.model.fit(self.X_train, self.y_train, epochs=100, batch_size=batch_size, verbose=1)
def train_model(lowdata, labels, results, p): # Print parameters print('\n' + ' '.join(map(str, p))) # Split data #X_train, X_test, y_train, y_test = train_test_split(lowdata, labels, test_size=0.2, random_state=29, shuffle=True) # Cross validation n_split = 5 scores = [] for train_index, test_index in KFold(n_split).split(lowdata): X_train, X_test = lowdata[train_index], lowdata[test_index] y_train, y_test = labels[train_index], labels[test_index] # Define model (complexity is a function of input dimensionality) if p[5] > 8: k = 32 elif p[5] >= 3: k = 8 else: k = 3 model = Sequential() model.add( Dense(2 * k, activation='relu', input_dim=X_train.shape[1])) model.add(Dropout(0.5)) model.add(Dense(k, activation='relu')) model.add(Dense(n_classes, activation='softmax')) loss = categorical_crossentropy #optimizer = Adadelta(lr=0.0005) optimizer = Adam(lr=0.0005) model.compile(loss=loss, optimizer=optimizer, metrics=['categorical_accuracy']) #print(model.summary()) # Train model n_epochs = 30 history = model.fit(X_train, y_train, batch_size=32, epochs=n_epochs, verbose=0, validation_data=(X_test, y_test)) #plot(history) scores.append(eval_metrics(model, X_test, y_test, class_names)) # Evaluate model results = { 'params': p, 'history': history.history, 'score': scores } return results
def get_model(): model = Sequential() model.add( Dense(99, input_dim=1, activation='softmax', kernel_initializer='he_uniform')) model.add(Dense(120, activation='tanh', kernel_initializer='he_uniform')) model.add(Dense(256, activation='tanh', kernel_initializer='he_uniform')) model.add(Dense(90, activation='relu', kernel_initializer='he_uniform')) model.add(Dense(20, activation='tanh', kernel_initializer='he_uniform')) model.add(Dense(10, activation='tanh', kernel_initializer='he_uniform')) model.add(Dense(1)) model.compile(loss='mse', optimizer='adam') return model
def embedding_test(): ''' 模型将输入一个大小为 (batch, input_length) 的整数矩阵。 输入中最大的整数(即词索引)不应该大于 999 (词汇表大小) 现在 model.output_shape == (None, 10, 64),其中 None 是 batch 的维度。 ''' model = Sequential() # model.add(Embedding(1000, 64, input_length=10)) model.add(Embedding(160, 4)) # input_array = np.random.randint(1000, size=(32, 10)) input_array = np.random.randint(160, size=(5, 4, 4)) model.compile('rmsprop', 'mse') output_array = model.predict(input_array) print(output_array.shape) return model
def define_discriminator(self): model = Sequential() model.add( Dense(256, activation='relu', kernel_initializer='he_uniform', input_dim=self.input_dim)) model.add(Dropout(0.3)) model.add(Dense(128, activation='relu')) model.add(Dropout(0.3)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def create_rnn_model(self, n_timesteps, n_features, n_outputs, model_type): model = Sequential() if model_type == "GRU": model.add(GRU(100, input_shape=(n_timesteps, n_features))) else: model.add(LSTM(100, input_shape=(n_timesteps, n_features))) model.add(Dropout(0.5)) model.add(Dense(100, activation='relu')) model.add(Dense(n_outputs, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() return model
def custom_net(self, units, dropout, batch_size, epochs): model = Sequential() model.add( Dense(units[0], activation="elu", input_shape=(len(cat_cols + con_cols), ))) for i in range(1, len(units)): model.add(Dense(units[i], activation="elu")) model.add(BatchNormalization()) model.add(Dropout(dropout)) model.add(Dense(1)) model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.001), loss='mse') # self.nn_inp_names = model.input_names return model
def __init__(self, game: GridGame): super().__init__(game) # game params self.board_height = game.board_height self.board_width = game.board_width example_board = game.create_board() self.action_size = len(game.get_valid_moves(example_board)) self.epochs_completed = 0 self.epochs_to_train = 100 args = Namespace(lr=0.001, dropout=0.3, epochs=10, batch_size=64, num_channels=512) self.checkpoint_name = 'random weights' self.args = args num_channels = 512 kernel_size = [3, 3] dropout = 0.3 model = Sequential() # regularizer = regularizers.l2(0.00006) regularizer = regularizers.l2(0.0001) model.add(Conv2D(num_channels, kernel_size, padding='same', activation='relu', input_shape=(self.board_height, self.board_width, 1), activity_regularizer=regularizer)) model.add(Conv2D(num_channels, kernel_size, padding='same', activation='relu', activity_regularizer=regularizer)) model.add(Conv2D(num_channels, kernel_size, activation='relu', activity_regularizer=regularizer)) model.add(Conv2D(num_channels, kernel_size, activation='relu', activity_regularizer=regularizer)) model.add(Dropout(dropout)) model.add(Dropout(dropout)) model.add(Flatten()) model.add(Dense(self.action_size + 1)) model.compile('adam', 'mean_squared_error') self.model = model