def __init__(self, input_shape, action_space): self.model = models.Sequential() self.model.add( layers.Conv2D(32, 8, strides=(4, 4), padding="valid", activation="relu", input_shape=input_shape, data_format="channels_first")) self.model.add( layers.Conv2D(64, 4, strides=(2, 2), padding="valid", activation="relu", input_shape=input_shape, data_format="channels_first")) self.model.add( layers.Conv2D(64, 3, strides=(1, 1), padding="valid", activation="relu", input_shape=input_shape, data_format="channels_first")) self.model.add(layers.Flatten()) self.model.add(layers.Dense(512, activation="relu")) self.model.add(layers.Dense(action_space)) self.model.compile(loss="mean_squared_error", optimizer=optimizers.RMSprop(lr=0.00025, rho=0.95, epsilon=0.01), metrics=["accuracy"]) self.model.summary()
def getAcc(model_config: 'tuple model hyperparameters', data: 'tuple train and test data')->'float loss and acc on test data': xtrain, ytrain, xval, yval = data nnodes_h1, dropout_h1, nnodes_h2, dropout_h2, merge, nbatch, opt, nepoch, lr = model_config nframe = xtrain.shape[1] isize = xtrain.shape[2] model = Sequential() model.add(Bidirectional(LSTM(nnodes_h1, return_sequences = True, dropout= dropout_h1), merge_mode = merge, input_shape = (nframe, isize))) model.add(Bidirectional(LSTM(nnodes_h2, return_sequences = False, dropout = dropout_h2), merge_mode = merge)) # model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) # chose optimiser if opt == 'adam': opt= optimizers.Adam(learning_rate = lr) elif opt == 'sgd': opt= optimizers.SGD(learning_rate = lr) else: opt = optimizers.RMSprop(learning_rate = lr) model.compile(loss = 'binary_crossentropy', optimizer = opt, metrics = ['accuracy']) model.fit(xtrain, ytrain, batch_size=nbatch, epochs= nepoch, verbose = 0) loss, acc = model.evaluate(xval, yval, verbose = 0) clear_session() return loss, acc
def tsnn_network(img_d=224, img_c=3): anchor_input = Input(( img_d, img_d, img_c, ), name='anchor_input') positive_input = Input(( img_d, img_d, img_c, ), name='positive_input') negative_input = Input(( img_d, img_d, img_c, ), name='negative_input') # Shared embedding layer for positive and negative items Shared_DNN = create_base_network() encoded_anchor = Shared_DNN(anchor_input) encoded_positive = Shared_DNN(positive_input) encoded_negative = Shared_DNN(negative_input) merged_vector = concatenate( [encoded_anchor, encoded_positive, encoded_negative], axis=-1, name='merged_layer') model = Model(inputs=[anchor_input, positive_input, negative_input], outputs=merged_vector) #model.compile(optimizer=optimizers.RMSprop(lr=2e-5), loss=triplet_loss) model.compile(optimizer=optimizers.RMSprop(lr=1e-3), loss=triplet_loss) return model
def create_model(input_shape): model = models.Sequential([ layers.Convolution2D( filters=16, input_shape=input_shape, kernel_size=(4, 4), padding="same", activation="relu", ), layers.MaxPooling2D(pool_size=(2, 2)), layers.Convolution2D(filters=32, kernel_size=(4, 4), padding="same", activation="relu"), layers.MaxPooling2D(input_shape=(2, 2)), layers.Convolution2D(filters=64, kernel_size=(3, 3), padding="same", activation="relu"), layers.Flatten(), layers.Dense(units=256, activation="relu"), layers.Dense(units=6, activation="softmax"), ]) model.compile( optimizer=optimizers.RMSprop(lr=2e-4), loss="sparse_categorical_crossentropy", metrics=["acc"], ) return model
def get_original_model(input_size, n_actions, lr): """Returns short conv model with mask at the end of the network. Copy of network from papers.""" screen_input = layers.Input(input_size) actions_input = layers.Input(n_actions) x = layers.Lambda(lambda x: x / 255.0)(screen_input) x = layers.Conv2D(16, (8, 8), strides=(4, 4))(x) x = layers.ReLU()(x) x = layers.Conv2D(32, (4, 4), strides=(2, 2))(x) x = layers.ReLU()(x) x = layers.Flatten()(x) x = layers.Dense(256, activation='relu')(x) x = layers.Dense(n_actions)(x) x = layers.Multiply()([x, actions_input]) model = models.Model(inputs=[screen_input, actions_input], outputs=x) optimizer = optimizers.RMSprop(lr=lr, rho=0.95, epsilon=0.01, momentum=0.95) model.compile(optimizer, loss='mse') return model
def __init__(self, model, learning_rate=7e-3, gamma=0.99, batch_size=64, value_c=0.5, entropy_c=1e-4): self.model = model self.gamma = gamma self.batch_size = batch_size self.value_c = value_c # Coefficients are used for the loss terms. self.entropy_c = entropy_c # Define optimiser and losses used to train the model. self.model.compile( optimizer=ko.RMSprop(lr=learning_rate), #optimizer=ko.Adam(learning_rate=learning_rate, beta_1=0.9, beta_2=0.999, amsgrad=False), loss=[self._logits_loss, self._value_loss]) # Structures for storing data used during training. self.actions = np.empty((batch_size, ), dtype=np.int32) self.rewards, self.dones, self.values = np.empty((3, batch_size)) self.observations = np.empty((batch_size, ) + self.model.in_shape) self.ep_rewards = [0.0] self.t = 0 # Total timesteps seen. self.i = 0 # Counter used to determine when to train (batch size reached). self.update_count = 0 # Number of updates completed.
def compile_model_and_train(classifier, regressor, lr, labels, val_classifier_imgs, val_regressor_imgs, val_labels, val_boxes): classifier.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=lr), metrics=['acc']) regressor.compile(loss='mean_squared_error', optimizer=optimizers.Adam(lr=lr), metrics=['acc']) with open(OUTPUT_STATISTICS_PATH, 'w', newline='') as statistics_file: # Train models for epoch in range(NUM_EPOCHS): print("\n\nEPOCH: ", epoch) # Create a list of batches dataset = create_batch_list(labels, positive_box_threshold=0.8, negative_box_threshold=0.3) error_train_classifier = [] error_train_regressor = [] # Train models on every batch for (classifier_images, regressor_images, classes, boxes) in dataset: error_train_classifier.append(classifier.train_on_batch(np.array(classifier_images), np.array(classes))) error_train_regressor.append(regressor.train_on_batch(np.array(regressor_images), np.array(boxes))) error_val_classifier = classifier.test_on_batch(np.array(val_classifier_imgs), np.array(val_labels)) error_val_regressor = regressor.test_on_batch(np.array(val_regressor_imgs), np.array(val_boxes)) # Calculate statistics mean_error_train_classifier = mean(error_train_classifier[:][0]) mean_accuracy_train_classifier = mean(error_train_classifier[:][1]) mean_error_train_regressor = mean(error_train_regressor[:][0]) mean_accuracy_train_regressor = mean(error_train_regressor[:][1]) print("Classifier train error: %lf, Accuracy: %lf" % (mean_error_train_classifier, mean_accuracy_train_classifier)) print("Classifier validation error: %lf, Accuracy: %lf" % (error_val_classifier[0], error_val_classifier[1])) print("Regressor train error: %lf, Accuracy: %lf" % (mean_error_train_regressor, mean_accuracy_train_regressor)) print("Regressor validation error: %lf, Accuracy: %lf" % (error_val_regressor[0], error_val_regressor[1])) # Save statistics statistics_writer = writer(statistics_file, delimiter=',') statistics_writer.writerow([epoch + 1, mean_error_train_classifier, mean_accuracy_train_classifier, mean_error_train_regressor, mean_accuracy_train_regressor])
def get_ann( n_hidden=4, n_neurons=20, kernel_initializer="he_normal", bias_initializer=initializers.Ones() ): model = Sequential() model.add( Dense( units=n_neurons, input_dim=14, kernel_initializer=kernel_initializer, bias_initializer=bias_initializer, ) ) model.add(keras.layers.LeakyReLU(alpha=0.2)) model.add(Dropout(rate=0.1)) for _ in range(n_hidden): model.add( Dense( units=n_neurons, kernel_initializer=kernel_initializer, bias_initializer=bias_initializer, ) ) model.add(keras.layers.LeakyReLU(alpha=0.2)) model.add(Dropout(rate=0.1)) model.add(Dense(units=1, activation="linear")) optimizer = optimizers.RMSprop() model.compile(loss="mse", optimizer=optimizer, metrics=["mse", "mae"]) return model
def MobileNet_impl(alpha=1): data_in = Input(shape=(28, 28, 1)) x = ZeroPadding2D(padding=(2, 2))(data_in) x = Conv2D(int(32 * alpha), (3, 3), padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = depthwise_sep_conv(x, 64, alpha) x = depthwise_sep_conv(x, 128, alpha, strides=(2, 2)) x = depthwise_sep_conv(x, 128, alpha) x = depthwise_sep_conv(x, 256, alpha, strides=(2, 2)) x = depthwise_sep_conv(x, 256, alpha) x = depthwise_sep_conv(x, 512, alpha, strides=(2, 2)) for _ in range(5): x = depthwise_sep_conv(x, 512, alpha) x = depthwise_sep_conv(x, 1024, alpha, strides=(2, 2)) x = depthwise_sep_conv(x, 1024, alpha) x = GlobalAveragePooling2D()(x) x = Dense(units=10)(x) x = Activation('softmax')(x) mobilenet_model = keras.Model(inputs=data_in, outputs=x, name="mobilenet_model") mobilenet_model.compile(optimizer=optimizers.RMSprop(lr=0.01), loss=keras.losses.categorical_crossentropy, metrics=['accuracy']) return mobilenet_model
def __init__(self, encoding_size, gene_size, generator_factory: Callable[[int, int], Model] = _build_generator, encoder_factory: Callable[[int, int], Model] = _build_encoder, discriminator_factory: Callable[[int, int], Model] = _build_discriminator): super().__init__(encoding_size, gene_size, generator_factory, encoder_factory, discriminator_factory) discr_optimizer = optimizers.RMSprop(learning_rate=0.0075, rho=0.85, momentum=0.1) self._generator.trainable = True self._encoder.trainable = False self._discriminator.trainable = False discr_gen_output = self._discriminator((self._generator.inputs[0], self._generator.output)) self._train_gen_w_discr = Model(self._generator.inputs, discr_gen_output, name='train-generator-with-discriminator') self._train_gen_w_discr.compile(optimizer=discr_optimizer, loss=losses.binary_crossentropy) gen_output = self._generator((self._encoder.output, self._generator.inputs[1])) self._train_gen_w_enc = Model((self._encoder.inputs, self._generator.inputs[1]), gen_output, name='train-generator-with-encoder') self._train_gen_w_enc.compile(optimizer=discr_optimizer, loss=losses.mse) self._generator.trainable = False self._encoder.trainable = True self._discriminator.trainable = False discr_enc_output = self._discriminator((self._encoder.output, self._encoder.input)) self._train_enc_w_discr = Model(self._encoder.inputs, discr_enc_output, name='train-encoder-with-discriminator') self._train_enc_w_discr.compile(optimizer=discr_optimizer, loss=losses.binary_crossentropy) enc_output = self._encoder(self._generator.output) self._train_enc_w_gen = Model(self._generator.inputs, enc_output, name='train-encoder-with-generator') self._train_enc_w_gen.compile(optimizer=discr_optimizer, loss=losses.mse) self._generator.trainable = False self._encoder.trainable = False self._discriminator.trainable = True self._discriminator.compile(optimizer=discr_optimizer, loss=losses.binary_crossentropy)
def learn_embedding_model(cf, x, y, embedding_size, num_epochs, batch_size, num_sampled): """ Use tensorflow to learn embedding model. """ vocab_size = len(cf.sensornames) print('parameters', vocab_size, embedding_size, num_sampled) model = NCEModel(vocab_size=vocab_size, embeddings_size=embedding_size, nce_num_sampled=num_sampled) optimizer = optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0) model.compile(optimizer=optimizer, loss=empty_loss) logdir = create_logdir() # prepare tensorboard callback tensorboard_callback = keras.callbacks.TensorBoard(logdir, profile_batch=0) os.makedirs(logdir, exist_ok=True) model.fit(x=[x.reshape([-1, 1]), y.reshape([-1, 1])], y=y, epochs=num_epochs, batch_size=64, callbacks=[tensorboard_callback]) sensor_x = np.arange(vocab_size) embeddings = model.predict( (sensor_x.reshape([-1, 1]), sensor_x.reshape([-1, 1]))) normalized_embeddings = normalize_embeddings(embeddings) if cf.save_model: print('Saving model.') embeddings_dir = 'model' embeddings_filename = os.path.join(embeddings_dir, 'embeddings') np.save(embeddings_filename, normalized_embeddings) return normalized_embeddings
def train_model(model, train_folder, test_folder, train_batchsize, val_batchsize, image_size, filename, epochs = 3,classmode='categorical', lr=1e-4): # No Data augmentation train_datagen = ImageDataGenerator(rescale=1./255) validation_datagen = ImageDataGenerator(rescale=1./255) # Data Generator for Training data train_generator = train_datagen.flow_from_directory( train_folder, target_size=(image_size, image_size), batch_size=train_batchsize, class_mode=classmode) # Data Generator for Validation data validation_generator = validation_datagen.flow_from_directory( test_folder, target_size=(image_size, image_size), batch_size=val_batchsize, class_mode=classmode, shuffle=False) # Compile the model model.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(lr=lr), metrics=['acc']) # Train the Model history = model.fit_generator( train_generator, train_generator.n // train_batchsize, epochs=epochs, workers=4, validation_data=validation_generator, validation_steps=validation_generator.n // val_batchsize) # Save the Model model.save(filename) return model, history
def createModel(): model = Sequential() model.add(Conv2D(32, (3, 3), padding='same', input_shape=(64, 64, 3))) model.add(Activation('relu')) model.add(Conv2D(128, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Conv2D(128, (3, 3), padding='same')) model.add(Activation('relu')) model.add(Conv2D(128, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Conv2D(128, (3, 3), padding='same')) model.add(Activation('relu')) model.add(Conv2D(128, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='softmax')) model.compile(optimizers.RMSprop(lr=0.0005, decay=1e-6), loss="categorical_crossentropy", metrics=["accuracy"]) return model
def __init__(self, train=True, discount_factor=0.99, learning_rate=0.0001, step_size=20): self.available_screen_features = AVAILABLE_SCREEN_FEATURES self.available_minimap_features = AVAILABLE_MINIMAP_FEATURES self.available_player_features = AVAILABLE_PLAYER_FEATURES self.available_actions = AVAILABLE_ACTIONS self.available_arguments = AVAILABLE_ARGUMENTS self.available_argument_ids = [ argument.id for argument in AVAILABLE_ARGUMENTS ] self.default_arguments = DEFAULT_ARGUMENTS self.is_training = train self.discount_factor = discount_factor self.learning_rate = learning_rate self.optimizer = optimizers.RMSprop(learning_rate=learning_rate) self.step_size = step_size self.memory = [] self.obs_spec = None self.action_spec = None self.model = None self.last_state = None self.last_action = None
def get_optimizer(op_type, learning_rate): if op_type == 'sgd': return optimizers.SGD(learning_rate) elif op_type == 'rmsprop': return optimizers.RMSprop(learning_rate) elif op_type == 'adagrad': return optimizers.Adagrad(learning_rate) elif op_type == 'adadelta': return optimizers.Adadelta(learning_rate) elif op_type == 'adam': return optimizers.Adam(learning_rate, clipnorm=5) elif op_type == 'adamw': return AdamWeightDecay( learning_rate=learning_rate, weight_decay_rate=0.01, beta_1=0.9, beta_2=0.999, epsilon=1e-6, exclude_from_weight_decay=["layer_norm", "bias"]) elif op_type == 'adamw_2': return create_optimizer(init_lr=learning_rate, num_train_steps=9000, num_warmup_steps=0) elif op_type == 'adamw_3': return create_optimizer(init_lr=learning_rate, num_train_steps=9000, num_warmup_steps=100) else: raise ValueError('Optimizer Not Understood: {}'.format(op_type))
def createModel(nb_filters1=64, nb_filters2=128): model = Sequential() # First Convolution Layer model.add( Conv2D(nb_filters1, kernel_size=5, activation='relu', input_shape=(img_width, img_height, 1))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) # Second Convolution Layer model.add(Conv2D(nb_filters2, kernel_size=3, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(BatchNormalization()) model.add(Dropout(0.2)) # 2D to 1D model.add(Flatten()) # Output Layer model.add(Dense(classes_num, activation='softmax')) model.compile( loss= 'categorical_crossentropy', # tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), optimizer=optimizers.RMSprop( lr=lr), #optimizers.SGD(lr=lr,momentum=0.1), metrics=[tf.keras.metrics.CategoricalAccuracy()]) return model
def __init__(self, hull, lr, mmnt=0., wd=0, lr_decay=None, warmup=0, grad_limit=-1, grad_accum=1, update_scope=None, scope='RMSPROP'): super(RMSProp, self).__init__(scope) self.hull = hull self.wd = wd / 2. self.update_scope = update_scope self.grad_accum = grad_accum self.cnt = 0 if grad_limit < 0: grad_limit = None if lr_decay is not None: lr = lr_decay(lr) if warmup>0: lr = WarmUpWrapper(warmup, lr) self.optz = optimizers.RMSprop(lr, momentum=mmnt, clipvalue=grad_limit) if getattr(self.hull, '_in_ema_mode', False): self.optz = tfa.optimizers.MovingAverage(self.optz) def average_op(itself, var, average_var): decay = tf.constant(self.hull.decay_fn(self.hull.step), dtype=tf.float32) return tf.keras.backend.moving_average_update(average_var, var, decay) self.optz.average_op = MethodType(average_op, self.optz) self.hull._optz = self.optz
def model_config(): train_data_shape = (800, 1, 1000) kernel_divergence_fn = lambda q, p, _: tfp.distributions.kl_divergence( q, p) / (train_data_shape[0] * 1.0) model_vi = Sequential() model_vi.add(tf.keras.layers.InputLayer(train_data_shape[1:], name="input")) model_vi.add(tf.keras.layers.Flatten()) model_vi.add( tfp.layers.DenseFlipout(500, activation='relu', kernel_divergence_fn=kernel_divergence_fn)) model_vi.add( tfp.layers.DenseFlipout(100, activation='relu', kernel_divergence_fn=kernel_divergence_fn)) model_vi.add( tfp.layers.DenseFlipout(50, activation='relu', kernel_divergence_fn=kernel_divergence_fn)) model_vi.add( tfp.layers.DenseFlipout(6, activation='softmax', kernel_divergence_fn=kernel_divergence_fn)) model_vi.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4), metrics=['accuracy']) model_vi.summary() return model_vi
def lstm_for_dynamics(cf_trunc, num_epochs, seq_num=10, deployment_mode='train'): features = np.transpose(cf_trunc) states = np.copy(features[:, :]) #Rows are time, Columns are state values # Need to make batches of 10 input sequences and 1 output total_size = np.shape(features)[0] - seq_num input_seq = np.zeros(shape=(total_size, seq_num, np.shape(states)[1])) output_seq = np.zeros(shape=(total_size, np.shape(states)[1])) for t in range(total_size): input_seq[t, :, :] = states[None, t:t + seq_num, :] output_seq[t, :] = states[t + seq_num, :] idx = np.arange(total_size) np.random.shuffle(idx) input_seq = input_seq[idx, :, :] output_seq = output_seq[idx, :] # Model architecture model = Sequential() model.add(LSTM(32, input_shape=( seq_num, np.shape(states)[1]))) # returns a sequence of vectors of dimension 32 model.add(Dense(np.shape(states)[1], activation='linear')) # design network my_adam = optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0) filepath = "best_weights_lstm.h5" checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min', save_weights_only=True) callbacks_list = [checkpoint] # fit network model.compile(optimizer=my_adam, loss='mean_squared_error', metrics=[coeff_determination]) if deployment_mode == 'train': train_history = model.fit( input_seq, output_seq, epochs=num_epochs, batch_size=16, validation_split=0.33, callbacks=callbacks_list) #validation_split = 0.1 np.save('Train_Loss.npy', train_history.history['loss']) np.save('Val_Loss.npy', train_history.history['val_loss']) model.load_weights(filepath) return model
def build_model(): opt = optimizers.RMSprop(lr=learning_rate) model = tf.keras.Sequential() #lstm encoder model.add( layers.GRU(n_hidden, input_shape=(OBSERVE_LENGTH, dim_input), return_sequences=False, stateful=False, dropout=0.2)) model.add(layers.RepeatVector(PREDICT_LENGTH)) #lstm decoder model.add( layers.GRU(n_hidden, return_sequences=True, stateful=False, dropout=0.2)) model.add( layers.TimeDistributed(layers.Dense(3), input_shape=(PREDICT_LENGTH, None))) model.add(layers.Activation('linear')) model.compile(loss='mse', optimizer=opt) print(model.summary()) return model
def main(epochs=400): seq_len = 64 batch_size = 64 data_path = Path('preprocessed') output_path = output_path_name() raw_text = load_raw_text(data_path) train_batches, char2index = load_data(raw_text, seq_len, batch_size) model = build_model(batch_size=batch_size, embedding_dim=32, num_lstm_layers=2, lstm_dim=192, dropout_proportion=0.0, seq_len=seq_len, vocab_size=len(char2index)) model.summary() model.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(clipnorm=5.0), metrics=['accuracy']) output_path.mkdir() print(f'Saving the model to {output_path}') save_net(model, char2index, output_path) cb = callbacks(output_path, raw_text, model, char2index) hist = model.fit(train_batches, epochs=epochs, shuffle=False, callbacks=cb, verbose=1) save_weights(model, output_path) save_training_history(hist, output_path)
def learning_tensor_model(self, layer_units_list, epochs_count, model_name): """모델 생성 및 학습""" model = models.Sequential() input_layer_unit = [layer_units_list[0]] inter_layer_unit = layer_units_list[1:-1] output_layer_unit = [layer_units_list.pop()] model.add( layers.Dense(input_layer_unit.pop(), activation='relu', input_shape=(100, ))) for inter_unit in input_layer_unit: model.add(layers.Dense(inter_unit, activation='relu')) model.add(layers.Dense(output_layer_unit.pop(), activation='sigmoid')) model.compile(optimizer=optimizers.RMSprop(lr=0.001), loss=losses.binary_crossentropy, metrics=[metrics.binary_accuracy]) model.fit(self.x_train, self.y_train, epochs=epochs_count, batch_size=500) self.save_tensor_model(model, model_name) return model
def create_model_v15(show_summary=False): model = Sequential() model.add(Conv2D(32, (8, 8), padding='same', input_shape=(21,20,3))) model.add(Activation('relu')) model.add(Conv2D(64, (8, 8))) model.add(Activation('relu')) model.add(Dropout(0.25)) model.add(Conv2D(64, (3, 3), padding='same')) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3))) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3))) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Conv2D(128, (3, 3), padding='same')) model.add(Activation('relu')) model.add(Conv2D(128, (3, 3))) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(8, activation='softmax')) model.compile(optimizers.RMSprop(lr=0.0005, decay=1e-5), loss="categorical_crossentropy", metrics=["categorical_accuracy"]) if show_summary: model.summary() return model
def __init__(self, model): self.params = {'value': 0.5, 'entropy': 0.0001, 'gamma': 0.99} self.model = model self.model.compile( optimizer=ko.RMSprop(lr=0.0007), # define separate losses for policy logits and value estimate loss=[self._logits_loss, self._value_loss])
def get_expanded_model(input_size, n_actions, lr): """Returns short conv model with mask at the end of the network. Network is interpretation of original network from papers.""" screen_input = layers.Input(input_size) actions_input = layers.Input(n_actions) x = layers.Lambda(lambda x: x / 255.0)(screen_input) x = layers.Conv2D(16, (3, 3), padding='same')(x) x = layers.Conv2D(16, (3, 3), padding='same')(x) x = layers.Conv2D(16, (3, 3), padding='same')(x) x = layers.Conv2D(16, (3, 3), padding='same')(x) x = layers.ReLU()(x) x = layers.Conv2D(32, (3, 3), padding='same')(x) x = layers.Conv2D(32, (3, 3), padding='same')(x) x = layers.ReLU()(x) x = layers.Flatten()(x) x = layers.Dense(256, activation='relu')(x) x = layers.Dense(n_actions)(x) x = layers.Multiply()([x, actions_input]) model = models.Model(inputs=[screen_input, actions_input], outputs=x) optimizer = optimizers.RMSprop(lr=lr, rho=0.95, epsilon=0.01, momentum=0.95) model.compile(optimizer, loss='mse') return model
def getModel(): try: return load_model('./sentiment_model.h5') except: # 모델 구성 train_x = [term_frequency(d) for d, _ in train_docs] test_x = [term_frequency(d) for d, _ in test_docs] train_y = [c for _, c in train_docs] test_y = [c for _, c in test_docs] x_train = np.asarray(train_x).astype('float32') x_test = np.asarray(test_x).astype('float32') y_train = np.asarray(train_y).astype('float32') y_test = np.asarray(test_y).astype('float32') model = models.Sequential() model.add(layers.Dense(64, activation='relu', input_shape=(500, ))) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) # # 모델 학습 과정 model.compile(optimizer=optimizers.RMSprop(lr=0.001), loss=losses.binary_crossentropy, metrics=[metrics.binary_accuracy]) # # 모델 학습 model.fit(x_train, y_train, epochs=15, batch_size=512) results = model.evaluate(x_test, y_test) # 모델 저장 model.save('sentiment_model.h5') return model
def get_opt(): if opt == 'adam': return optimizers.Adam(lr=lr, clipnorm=1.) elif opt == 'rmsprop': return optimizers.RMSprop(lr=lr, clipnorm=1.) else: raise Exception('Only Adam and RMSProp are available here')
def main(): #file = r'./db/fucDatasetReg_1F_NoLinear.csv' #file = r'./db/fucDatasetReg_2F.csv' file = r'./db/fucDatasetReg_3F_1000.csv' x_train, x_test, y_train, y_test = getCsvDataset(file) lr = 1e-3 EPOCHES = 200 # optimizer = optimizerTf(lr=lr) # losses,_ = trainModel(x_train,y_train,optimizer,epochs=EPOCHES) # plotLoss(losses) opts = [] # fast group opts.append((optimizers.SGD(learning_rate=lr), 'SGD')) opts.append((optimizers.RMSprop(learning_rate=lr), 'RMSprop')) opts.append((optimizers.Adam(learning_rate=lr), 'Adam')) opts.append((optimizers.Adamax(learning_rate=lr), 'Adamax')) opts.append((optimizers.Nadam(learning_rate=lr), 'Nadam')) # # slow group opts.append((optimizers.Adadelta(learning_rate=lr), 'Adadelta')) opts.append((optimizers.Adagrad(learning_rate=lr), 'Adagrad')) opts.append((optimizers.Ftrl(learning_rate=lr), 'Ftrl')) lossesDict = {} for opti, name in opts: losses, _ = trainModel(x_train, y_train, opti, epochs=EPOCHES) lossesDict[name] = losses #print(name, losses) plotLossDict(lossesDict)
def run_experiment(train_generator, validation_generator, parameters): model = models.Sequential() model.add( layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4), metrics=['acc']) history = model.fit(train_generator, steps_per_epoch=parameters.steps_per_epoch, epochs=parameters.epochs, validation_data=validation_generator, validation_steps=p.validation_steps) return model, history
def __init__(self): """Init method. We define here a simple (shallow) CNN. """ self.num_train_samples = 0 self.num_feat = 1 self.num_labels = 1 self.is_trained = False self.model = models.Sequential() self.model.add( layers.Conv2D(32, (3, 3), activation='relu', input_shape=(40, 40, 3))) self.model.add(layers.MaxPooling2D((2, 2))) self.model.add(layers.Conv2D(64, (3, 3), activation='relu')) self.model.add(layers.MaxPooling2D((2, 2))) self.model.add(layers.Conv2D(128, (3, 3), activation='relu')) self.model.add(layers.MaxPooling2D((2, 2))) self.model.add(layers.Flatten()) self.model.add(layers.Dropout(0.6)) self.model.add(layers.Dense(256, activation='relu')) self.model.add(layers.Dense(1, activation='sigmoid')) self.model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=2e-3), metrics=['accuracy'])