def transfer_model(X_train,y_train,batch_size,epoch): base_model = ResNet50(include_top=False, weights='imagenet',input_shape=(224,224,3)) for layers in base_model.layers: layers.trainable = False model = Flatten()(base_model.output) model = Dense(128, activation='relu')(model) model = Dropout(0.5)(model) model = Dense(121, activation='softmax')(model) model = Model(inputs=base_model.input, outputs=model) model.compile(optimizer=keras.optimizers.Adam(lr=0.0001, decay=1e-5),loss='categorical_crossentropy',metrics=['accuracy']) callbacks = [ # 把TensorBoard日志写到'logs' keras.callbacks.TensorBoard(log_dir='./logs'), # 当categorical_accuracy,也就是分类精度在10个epoh之内都没提升时,降低learning rate keras.callbacks.ReduceLROnPlateau(monitor='categorical_accuracy', patience=10, verbose=2), # 当categorical_accuracy在15个epoch内没有提升的时候,停止训练 keras.callbacks.EarlyStopping(monitor='categorical_accuracy', patience=15, verbose=2)] model.fit(X_train,y_train, batch_size=batch_size, epochs=epoch) # parallel_model = multi_gpu_model(model, gpus=2) # parallel_model.compile(loss='categorical_crossentropy', # optimizer='adam',metrics=['accuracy']) # parallel_model.fit(X_train,y_train, batch_size=batch_size, epochs=epoch) return model
def _train(self) -> Model: data, label = load_data0_cycle() train_data, test_data, train_label, test_label = train_test_split( data, label, test_size=0.2) train_data = np.reshape(train_data, train_data.shape + (1, )) train_label = to_categorical(train_label) test_data = np.reshape(test_data, test_data.shape + (1, )) test_label = to_categorical(test_label) network_input = Input(shape=(8, 200, 1)) # 如果这里修改了网络结构,记得去下面修改可视化函数里的参数 network = Conv2D(filters=20, kernel_size=(1, 10))(network_input) network = Conv2D(filters=40, kernel_size=(4, 10), activation=tanh)(network) network = MaxPool2D((2, 2))(network) network = Flatten()(network) network = Dense(units=40, activation=tanh)(network) network = Dense(units=10, activation=softmax)(network) network = Model(inputs=[network_input], outputs=[network]) network.compile(optimizer=RMSprop(), loss=categorical_crossentropy, metrics=[categorical_accuracy]) network.summary() self.train_history = network.fit(train_data, train_label, batch_size=32, epochs=16) self.evaluate_history = network.evaluate(test_data, test_label) return network
def compiled_single_model(model_input_shape): input = Input(shape=model_input_shape) model = Flatten()(input) model = Dropout(.25)(model) model = Dense(400, activation='relu')(model) model = Dropout(.5)(model) model = Dense(200, activation='relu')(model) model = Dropout(.5)(model) model = Dense(100, activation='relu')(model) model = Dropout(.5)(model) model = Dense(num_classes, activation=last_activation)(model) model = Model(inputs=input, outputs=model) if len(args.gpus) > 1: model = keras.utils.multi_gpu_model(model, len(args.gpus), cpu_merge=False) model.compile( loss=loss, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy'], ) return model
def compiled_single_model(model_input_shape): input = Input(shape=model_input_shape) vgg = VGG16(weights='imagenet', input_shape=model_input_shape, include_top=False) for layer in vgg.layers: layer.trainable = False output_vgg = vgg(input) model = Flatten()(output_vgg) model = Dense(256, activation='relu')(model) model = Dropout(.2)(model) model = Dense(128, activation='relu')(model) model = Dropout(.2)(model) model = Dense(64, activation='relu')(model) model = Dropout(.2)(model) model = Dense(args.num_classes, activation=args.last_activation)(model) model = Model(inputs=input, outputs=model) if len(args.gpus) > 1: model = keras.utils.multi_gpu_model(model, len(args.gpus), cpu_merge=False) model.compile( loss=args.loss, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy'], ) return model
def counter_model(x_train_all, x_val_all, y_train_all, y_val_all): res_model = ResNet50(weights='imagenet', include_top=False, input_shape=(320, 320, 3)) model = res_model.output model = Flatten(name='flatten')(model) model = Dense(1024, activation='relu')(model) model = Dense(512, activation='relu', activity_regularizer=regularizers.l2(0.2))(model) leaf_pred = Dense(1)(model) epoch = 50 csv_logger = keras.callbacks.CSVLogger('training.log', separator=',') early_stop = EarlyStopping(monitor='val_loss', min_delta=0.03, mode='min', patience=8) model = Model(inputs=res_model.input, outputs=leaf_pred) model.compile(optimizer=Adam(lr=0.0001), loss='mse') fitted_model = model.fit(x_train_all, y_train_all, epochs=epoch, validation_data=(x_val_all, y_val_all), batch_size=16, callbacks=[csv_logger]) return model
def counter_model_augmentation(results_path, data, missing_labels): x_train = data[0] x_test = data[1] y_train_count = data[2] y_test_count = data[3] mask_value = -1 TYC = len(y_train_count) how_much_mask = missing_labels idx_mask = np.random.randint(TYC, size = int(TYC*how_much_mask)) y_train_count[idx_mask] = mask_value # y_train_count[:int(TYC*0.2)] = mask_value where_miss = np.where(y_train_count == mask_value) np.savetxt(results_path+'/missing_labels.csv', where_miss[0], delimiter=',') np.savetxt(results_path+'/train_labels.csv', y_train_count, delimiter=',') print('Missing Labels ', where_miss[0]) def MSE_masked_loss(y_true, y_pred): mask = K.cast(K.not_equal(y_true, mask_value), K.floatx()) return K.mean(K.square(y_pred*mask - y_true*mask), axis=-1) def mse_discrete_accuracy(y_true, y_pred): return K.mean(K.square(K.round(y_pred) - y_true), axis=-1) x_aug = ImageDataGenerator( width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, vertical_flip=True, ) x_aug.fit(x_train) res_model = ResNet50(weights='imagenet', include_top=False, input_shape=(317,309, 3)) model = res_model.output model = Flatten(name='flatten')(model) model = Dense(1536, activation='relu', name='count_dense1')(model) model = Dense(512, activation='relu', activity_regularizer=regularizers.l2(0.04), name='count_dense2')(model) leaf_pred = Dense(1, name='count')(model) epoch = 100 steps = int(len(x_train)/3) csv_logger = keras.callbacks.CSVLogger(results_path+'/training.log', separator=',') early_stop = EarlyStopping(monitor='val_loss', min_delta=0.05, mode='min', patience=12) checkpoint = ModelCheckpoint(results_path+'/checkpoint.hdf5', monitor='val_loss', verbose=1, save_best_only=True, mode='min') model = Model(inputs = res_model.input, outputs = leaf_pred) model.compile(optimizer=Adam(lr=0.0001), loss= MSE_masked_loss, metrics={'count': mse_discrete_accuracy}) fitted_model= model.fit_generator(x_aug.flow(x_train, y_train_count, batch_size=6), steps_per_epoch=steps, epochs=epoch, validation_data=(x_test, y_test_count), callbacks= [csv_logger, checkpoint, early_stop]) model.save(results_path+'/the_model.h5') return model
def model(input_size,output_size): print(input_size) inputs = Input(shape=input_size) model = Conv2D(9,9,activation="relu",padding='same') (inputs) model = MaxPooling2D(pool_size=(2,2)) (model) model = Conv2D(7,7,activation="relu",padding="same") (model) model = MaxPooling2D(pool_size=(2,2)) (model) model = Flatten()(model) output = Dense(output_size[1],activation="softmax") (model) model = Model(input=inputs,outputs = output) model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"]) return model
def train_model(logdir, hp): model2 = Flatten()(model.layers[-1].output) for unit in hp['units']: model2 = Dense(unit, activation='relu')(model2) model2 = Dropout(hp['dropout'])(model2) model2 = Dense(1, activation='sigmoid')(model2) model2 = Model(input=model.layers[0].input, output=model2) model2.summary() model2.layers[0].trainable = False plot_model(model2, to_file='model2.png', show_shapes=True, show_layer_names=False) model2 = multi_gpu_model(model2, gpus=2) model2.compile(optimizer=optimizers.Adam(lr=hp['lr'], decay=0.01), loss='binary_crossentropy', metrics=['accuracy']) cb = [callbacks.TensorBoard(log_dir=logdir)] history = model2.fit(x_train, y_train, validation_data=(x_test, y_test), batch_size=8, epochs=1000, callbacks=cb, verbose=2) # Plot training & validation accuracy values plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('Model accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.show() # Plot training & validation loss values plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.show() return model2
def model_Fun_CNN1(shape): input = Input(shape=shape, name='Inputs') model = Conv1D(1024, 5, activation='relu')(input) model = MaxPool1D(3)(model) model = Conv1D(512, 4, activation='relu')(model) model = MaxPool1D(3)(model) model = Conv1D(128, 4, activation='relu')(model) # model = MaxPool1D(2)(model) model = Flatten()(model) model = Dense(128, activation='relu')(model) output = Dense(1, activation='sigmoid')(model) model = Model(input, output) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model
def model_fashion_vgg16(): filepath = './model/model_cifar_vgg16.hdf5' (X_train, Y_train), (X_test, Y_test) = cifar10.load_data() # 32*32 X_train = X_train.astype('float32').reshape(-1, 32, 32, 3) X_test = X_test.astype('float32').reshape(-1, 32, 32, 3) X_train /= 255 X_test /= 255 y_train = Y_train.reshape(-1) y_test = Y_test.reshape(-1) ### modify print('Train:{},Test:{}'.format(len(X_train), len(X_test))) nb_classes = 10 y_train = np_utils.to_categorical(y_train, nb_classes) y_test = np_utils.to_categorical(y_test, nb_classes) print('data success') # base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(28, 28, 1)) model_vgg = VGG16(include_top=False, weights='imagenet', input_shape=(32, 32, 3)) # for layer in model_vgg.layers: # 冻结权重 # layer.trainable = False model = Flatten()(model_vgg.output) model = Dense(1024, activation='relu', name='fc1')(model) # model = Dropout(0.5)(model) model = Dense(512, activation='relu', name='fc2')(model) # model = Dropout(0.5)(model) model = Dense(10, activation='softmax', name='prediction')(model) model = Model(inputs=model_vgg.input, outputs=model, name='vgg16_pretrain') model.summary() model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) checkpoint = ModelCheckpoint(filepath=filepath, monitor='val_accuracy', mode='auto', save_best_only='True') model.fit(X_train, y_train, batch_size=128, nb_epoch=30, validation_data=(X_test, y_test), callbacks=[checkpoint]) model = load_model(filepath) score = model.evaluate(X_test, y_test, verbose=0) print(score)
def model_Fun_CNN2(shape): input = Input(shape=shape, name='Inputs') model = Conv2D(256, kernel_size=(3, 3), activation='relu')(input) model = MaxPool2D((2, 2))(model) # model = Conv2D(128, kernel_size=(3,3), activation='relu')(model) # model = MaxPool2D((2,2))(model) # model = Conv2D(32, kernel_size=(3,3), activation='relu')(model) # model = MaxPool2D((2,2))(model) model = Flatten()(model) model = Dense(128, activation='relu')(model) model = Dense(64, activation='relu')(model) output = Dense(1, activation='sigmoid')(model) model = Model(input, output) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model
def flower_model(X_train, y_train): base_model = ResNet50(include_top=False, weights='imagenet', input_shape=(224, 224, 3)) for layers in base_model.layers: layers.trainable = False model = Flatten()(base_model.output) model = Dense(128, activation='relu')(model) model = Dropout(0.5)(model) model = Dense(2, activation='softmax')(model) model = Model(inputs=base_model.input, outputs=model) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X_train, y_train, batch_size=128, epochs=5) return model
def counter_model_augmentation(x_train_all, x_val_all, y_train_all, y_val_all): x_aug = ImageDataGenerator( rotation_range=180, width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, vertical_flip=True, ) x_aug.fit(x_train_all) res_model = ResNet50(weights='imagenet', include_top=False, input_shape=(320, 320, 3)) model = res_model.output model = Flatten(name='flatten')(model) model = Dense(1024, activation='relu')(model) model = Dense(512, activation='relu', activity_regularizer=regularizers.l2(0.2))(model) leaf_pred = Dense(1)(model) epoch = 50 csv_logger = keras.callbacks.CSVLogger('training.log', separator=',') early_stop = EarlyStopping(monitor='val_loss', min_delta=0.03, mode='min', patience=8) model = Model(inputs=res_model.input, outputs=leaf_pred) model.compile(optimizer=Adam(lr=0.0001), loss='mse') fitted_model = model.fit_generator(x_aug.flow(x_train_all, y_train_all, batch_size=6), steps_per_epoch=len(x_train_all) * 2, epochs=epoch, validation_data=(x_val_all, y_val_all), callbacks=[csv_logger, early_stop]) return model '''
def create_random_classifier(im_shape): # create network with random initializing layers input_img = Input(shape=im_shape) cnn = Conv2D(128, (3, 3), activation='relu', padding='same', kernel_initializer='random_normal')(input_img) cnn = BatchNormalization()(cnn) cnn = MaxPooling2D((2, 2), padding='same')(cnn) cnn = Conv2D(64, (3, 3), activation='relu', padding='same', kernel_initializer='random_normal')(cnn) cnn = BatchNormalization()(cnn) cnn = MaxPooling2D((2, 2), padding='same')(cnn) cnn = Conv2D(32, (3, 3), activation='relu', padding='same', kernel_initializer='random_normal')(cnn) cnn = BatchNormalization()(cnn) encoded = MaxPooling2D((2, 2), padding='same')(cnn) classifier = Flatten()(encoded) classifier = Dense(5, activation='softmax', kernel_initializer='random_normal')( classifier) # softmax -> multiclass, multilabel classifier = Model(input_img, classifier) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc', 'mse', 'mae']) return classifier
def build_model(data_params_, model_params_): if model_params['model_type'] == 'ImageNet pretrain model': if model_params_['model'] == 'ResNet50': base_model = ResNet50(weights='imagenet', include_top=False, input_shape=data_params_['re_size']) elif model_params_['model'] == 'Xception': base_model = Xception(weights='imagenet', include_top=False, input_shape=data_params_['re_size']) elif model_params_['model'] == 'DenseNet121': base_model = DenseNet121(weights='imagenet', include_top=False, input_shape=data_params_['re_size']) model = base_model.output model = Flatten()(model) model = Dropout(model_params_['dr_rate'])(model) predictions = Dense(2, activation='softmax')(model) #class model = Model(inputs=base_model.input, outputs=predictions) elif model_params['model_type'] == 'Custom pretrain model': model = load_model(model_params_['custom_model_path']) optimizer = keras.optimizers.Adam(lr=model_params_['lr']) save_path = os.path.join(model_params_['save_dir'], model_params_['model_name'] + '.h5') checkpoint = ModelCheckpoint(save_path, monitor='val_loss', save_best_only=True, verbose=1) early_stop = EarlyStopping(monitor='val_loss', patience=model_params_['early_stop_rounds'], verbose=1) model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy']) return model, early_stop, checkpoint
def _build_model(self): input = Input(shape=(state_size_x, state_size_y, 4)) model = Conv2D(32, kernel_size=(8, 8), strides=4, activation='relu')(input) model = MaxPool2D((2, 2), padding='same')(model) model = Conv2D(64, kernel_size=(4, 4), strides=2, activation='relu')(model) model = MaxPool2D((2, 2), padding='same')(model) model = Conv2D(64, kernel_size=(3, 3), strides=1, activation='relu')(model) model = MaxPool2D((2, 2), padding='same')(model) model = Flatten()(model) input_agent_info = Input(shape=(16, )) input_action = Input(shape=(1, )) merge = Concatenate()([model, input_agent_info, input_action]) reshape = Reshape((657, 1))(merge) output = LSTM(64, input_shape=(657, 1))(reshape) #output = Dense(32, activation='relu')(output) actions_out = Dense(self.action_size, name='o_Policy', activation='softmax')(output) value_out = Dense(1, name='o_Value', activation='linear')(output) model = Model(inputs=[input, input_agent_info, input_action], outputs=[actions_out, value_out]) model.compile(loss={ 'o_Policy': self.logloss, 'o_Value': 'mse' }, loss_weights={ 'o_Policy': 1., 'o_Value': 0.5 }, optimizer=Adam(lr=self.learning_rate)) model.summary() return model
def model_fashion_vgg16(): filepath = './model/model_svhn_vgg16.hdf5' (X_train, y_train), (X_test, y_test) = SVNH_DatasetUtil.load_data() ### modify print('Train:{},Test:{}'.format(len(X_train), len(X_test))) model_vgg = VGG16(include_top=False, weights='imagenet', input_shape=(32, 32, 3)) # for layer in model_vgg.layers: # 冻结权重 # # layer.trainable = False # model_vgg = VGG16(include_top=False, weights='imagenet', input_shape=(32, 32, 3)) # model_vgg = VGG16(include_top=False, weights=None, input_shape=(32, 32, 3)) model = Flatten()(model_vgg.output) model = Dense(1024, activation='relu', name='fc1')(model) # model = Dropout(0.5)(model) model = Dense(512, activation='relu', name='fc2')(model) # model = Dropout(0.5)(model) model = Dense(10, activation='softmax', name='prediction')(model) model = Model(inputs=model_vgg.input, outputs=model, name='vgg16_pretrain') model.summary() model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) checkpoint = ModelCheckpoint(filepath=filepath, monitor='val_accuracy', mode='auto', save_best_only='True') model.fit(X_train, y_train, batch_size=64, nb_epoch=15, validation_data=(X_test, y_test), callbacks=[checkpoint]) model = load_model(filepath) score = model.evaluate(X_test, y_test, verbose=0) print(score)
class Network(object): def __init__(self, parameters, modelName=None): self.parameters = parameters self.gpus = self.parameters.NUM_GPUS # Q-learning self.discount = self.parameters.DISCOUNT self.epsilon = self.parameters.EPSILON self.frameSkipRate = self.parameters.FRAME_SKIP_RATE if self.parameters.GAME_NAME == "Agar.io": self.gridSquaresPerFov = self.parameters.GRID_SQUARES_PER_FOV # CNN if self.parameters.CNN_REPR: # (KernelSize, stride, filterNum) self.kernel_1 = self.parameters.CNN_L1 self.kernel_2 = self.parameters.CNN_L2 self.kernel_3 = self.parameters.CNN_L3 if self.parameters.CNN_USE_L1: self.stateReprLen = self.parameters.CNN_INPUT_DIM_1 elif self.parameters.CNN_USE_L2: self.stateReprLen = self.parameters.CNN_INPUT_DIM_2 else: self.stateReprLen = self.parameters.CNN_INPUT_DIM_3 else: self.stateReprLen = self.parameters.STATE_REPR_LEN if parameters.SQUARE_ACTIONS: self.actions = createDiscreteActionsSquare( self.parameters.NUM_ACTIONS, self.parameters.ENABLE_SPLIT, self.parameters.ENABLE_EJECT) else: self.actions = createDiscreteActionsCircle( self.parameters.NUM_ACTIONS, self.parameters.ENABLE_SPLIT, self.parameters.ENABLE_EJECT) self.num_actions = len(self.actions) else: import gym env = gym.make(self.parameters.GAME_NAME) if self.parameters.CNN_REPR: pass else: self.stateReprLen = env.observation_space.shape[0] self.num_actions = env.action_space.n self.actions = list(range(self.num_actions)) # ANN self.learningRate = self.parameters.ALPHA self.optimizer = self.parameters.OPTIMIZER if self.parameters.ACTIVATION_FUNC_HIDDEN == "elu": self.activationFuncHidden = "linear" # keras.layers.ELU(alpha=eluAlpha) else: self.activationFuncHidden = self.parameters.ACTIVATION_FUNC_HIDDEN self.activationFuncLSTM = self.parameters.ACTIVATION_FUNC_LSTM self.activationFuncOutput = self.parameters.ACTIVATION_FUNC_OUTPUT self.layers = parameters.Q_LAYERS if self.parameters.USE_ACTION_AS_INPUT: inputDim = self.stateReprLen + 4 outputDim = 1 else: inputDim = self.stateReprLen outputDim = self.num_actions if self.parameters.EXP_REPLAY_ENABLED: input_shape_lstm = (self.parameters.MEMORY_TRACE_LEN, inputDim) stateful_training = False self.batch_len = self.parameters.MEMORY_BATCH_LEN else: input_shape_lstm = (1, inputDim) stateful_training = True self.batch_len = 1 if self.parameters.INITIALIZER == "glorot_uniform": initializer = keras.initializers.glorot_uniform() elif self.parameters.INITIALIZER == "glorot_normal": initializer = keras.initializers.glorot_normal() else: weight_initializer_range = math.sqrt( 6 / (self.stateReprLen + self.num_actions)) initializer = keras.initializers.RandomUniform( minval=-weight_initializer_range, maxval=weight_initializer_range, seed=None) # CNN if self.parameters.CNN_REPR: if self.parameters.CNN_P_REPR: # RGB if self.parameters.CNN_P_RGB: channels = 3 # GrayScale else: channels = 1 if self.parameters.CNN_LAST_GRID: channels = channels * 2 self.input = Input(shape=(self.stateReprLen, self.stateReprLen, channels)) conv = self.input if self.parameters.CNN_USE_L1: conv = Conv2D(self.kernel_1[2], kernel_size=(self.kernel_1[0], self.kernel_1[0]), strides=(self.kernel_1[1], self.kernel_1[1]), activation='relu', data_format='channels_last')(conv) if self.parameters.CNN_USE_L2: conv = Conv2D(self.kernel_2[2], kernel_size=(self.kernel_2[0], self.kernel_2[0]), strides=(self.kernel_2[1], self.kernel_2[1]), activation='relu', data_format='channels_last')(conv) if self.parameters.CNN_USE_L3: conv = Conv2D(self.kernel_3[2], kernel_size=(self.kernel_3[0], self.kernel_3[0]), strides=(self.kernel_3[1], self.kernel_3[1]), activation='relu', data_format='channels_last')(conv) self.valueNetwork = Flatten()(conv) # Not pixel input else: # Vision grid merging self.input = Input(shape=(self.parameters.NUM_OF_GRIDS, self.stateReprLen, self.stateReprLen)) conv = self.input if self.parameters.CNN_USE_L1: conv = Conv2D(self.kernel_1[2], kernel_size=(self.kernel_1[0], self.kernel_1[0]), strides=(self.kernel_1[1], self.kernel_1[1]), activation='relu', data_format='channels_first')(conv) if self.parameters.CNN_USE_L2: conv = Conv2D(self.kernel_2[2], kernel_size=(self.kernel_2[0], self.kernel_2[0]), strides=(self.kernel_2[1], self.kernel_2[1]), activation='relu', data_format='channels_first')(conv) if self.parameters.CNN_USE_L3: conv = Conv2D(self.kernel_3[2], kernel_size=(self.kernel_3[0], self.kernel_3[0]), strides=(self.kernel_3[1], self.kernel_3[1]), activation='relu', data_format='channels_first')(conv) self.valueNetwork = Flatten()(conv) # Fully connected layers if self.parameters.NEURON_TYPE == "MLP": layerIterable = iter(self.layers) regularizer = keras.regularizers.l2(self.parameters.Q_WEIGHT_DECAY) if self.parameters.DROPOUT: constraint = maxnorm(self.parameters.MAXNORM) else: constraint = None if parameters.CNN_REPR: previousLayer = self.valueNetwork else: self.input = Input(shape=(inputDim, )) previousLayer = self.input for layer in layerIterable: if layer > 0: if self.parameters.DROPOUT: previousLayer = Dropout( self.parameters.DROPOUT)(previousLayer) previousLayer = Dense( layer, activation=self.activationFuncHidden, bias_initializer=initializer, kernel_initializer=initializer, kernel_regularizer=regularizer, kernel_constraint=constraint)(previousLayer) if self.parameters.ACTIVATION_FUNC_HIDDEN == "elu": previousLayer = (keras.layers.ELU( alpha=self.parameters.ELU_ALPHA))(previousLayer) if self.parameters.BATCHNORM: previousLayer = BatchNormalization()(previousLayer) if self.parameters.DROPOUT: previousLayer = Dropout(self.parameters.DROPOUT)(previousLayer) output = Dense(outputDim, activation=self.activationFuncOutput, bias_initializer=initializer, kernel_initializer=initializer, kernel_regularizer=regularizer, kernel_constraint=constraint)(previousLayer) self.valueNetwork = keras.models.Model(inputs=self.input, outputs=output) elif self.parameters.NEURON_TYPE == "LSTM": # Hidden Layer 1 # TODO: Use CNN with LSTM # if self.parameters.CNN_REPR: # hidden1 = LSTM(self.hiddenLayer1, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len) # else: # hidden1 = LSTM(self.hiddenLayer1, input_shape=input_shape_lstm, return_sequences = True, # stateful= stateful_training, batch_size=self.batch_len) hidden1 = LSTM(self.hiddenLayer1, input_shape=input_shape_lstm, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer)(self.valueNetwork) # Hidden 2 if self.hiddenLayer2 > 0: hidden2 = LSTM(self.hiddenLayer2, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer)( self.valueNetwork) # Hidden 3 if self.hiddenLayer3 > 0: hidden3 = LSTM(self.hiddenLayer3, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer)( self.valueNetwork) # Output layer output = LSTM(outputDim, activation=self.activationFuncOutput, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer)(self.valueNetwork) self.valueNetwork = keras.models.Model(inputs=self.input, outputs=output) # Create target network self.valueNetwork._make_predict_function() self.targetNetwork = keras.models.clone_model(self.valueNetwork) self.targetNetwork.set_weights(self.valueNetwork.get_weights()) if self.parameters.OPTIMIZER == "Adam": if self.parameters.GRADIENT_CLIP_NORM: optimizer = keras.optimizers.Adam( lr=self.learningRate, clipnorm=self.parameters.GRADIENT_CLIP_NORM, amsgrad=self.parameters.AMSGRAD) elif self.parameters.GRADIENT_CLIP: optimizer = keras.optimizers.Adam( lr=self.learningRate, clipvalue=self.parameters.GRADIENT_CLIP, amsgrad=self.parameters.AMSGRAD) else: optimizer = keras.optimizers.Adam( lr=self.learningRate, amsgrad=self.parameters.AMSGRAD) elif self.parameters.OPTIMIZER == "Nadam": optimizer = keras.optimizers.Nadam(lr=self.learningRate) elif self.parameters.OPTIMIZER == "Adamax": optimizer = keras.optimizers.Adamax(lr=self.learningRate) elif self.parameters.OPTIMIZER == "SGD": if self.parameters.NESTEROV: optimizer = keras.optimizers.SGD( lr=self.learningRate, momentum=self.parameters.NESTEROV, nesterov=True) else: optimizer = keras.optimizers.SGD(lr=self.learningRate) self.optimizer = optimizer self.valueNetwork.compile(loss='mse', optimizer=optimizer) self.targetNetwork.compile(loss='mse', optimizer=optimizer) self.model = self.valueNetwork if self.parameters.NEURON_TYPE == "LSTM": # We predict using only one state input_shape_lstm = (1, self.stateReprLen) self.actionNetwork = Sequential() hidden1 = LSTM(self.hiddenLayer1, input_shape=input_shape_lstm, return_sequences=True, stateful=True, batch_size=1, bias_initializer=initializer, kernel_initializer=initializer) self.actionNetwork.add(hidden1) if self.hiddenLayer2 > 0: hidden2 = LSTM(self.hiddenLayer2, return_sequences=True, stateful=True, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.actionNetwork.add(hidden2) if self.hiddenLayer3 > 0: hidden3 = LSTM(self.hiddenLayer3, return_sequences=True, stateful=True, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.actionNetwork.add(hidden3) self.actionNetwork.add( LSTM(self.num_actions, activation=self.activationFuncOutput, return_sequences=False, stateful=True, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer)) self.actionNetwork.compile(loss='mse', optimizer=optimizer) # if __debug__: print(self.valueNetwork.summary()) # print("\n") if modelName is not None: self.load(modelName) self.targetNetwork._make_predict_function() sess = tf.Session() sess.run(tf.global_variables_initializer()) self.graph = tf.get_default_graph() # Necessary for multiprocessing to warm up the network def dummy_prediction(self): if self.parameters.CNN_REPR: input_shape = ([ self.parameters.NUM_OF_GRIDS, self.stateReprLen, self.stateReprLen ]) else: input_shape = (self.stateReprLen, ) dummy_input = numpy.zeros(input_shape) dummy_input = numpy.array([dummy_input]) self.predict(dummy_input) def reset_general(self, model): session = K.get_session() for layer in model.layers: for v in layer.__dict__: v_arg = getattr(layer, v) if hasattr(v_arg, 'initializer'): initializer_method = getattr(v_arg, 'initializer') initializer_method.run(session=session) print('reinitializing layer {}.{}'.format(layer.name, v)) def reset_weights(self): self.reset_general(self.valueNetwork) self.reset_general(self.targetNetwork) def reset_hidden_states(self): self.actionNetwork.reset_states() self.valueNetwork.reset_states() self.targetNetwork.reset_states() def load(self, modelName): path = modelName + "model.h5" self.valueNetwork = keras.models.load_model(path) self.targetNetwork = load_model(path) def setWeights(self, weights): self.valueNetwork.set_weights(weights) def trainOnBatch(self, inputs, targets, importance_weights): if self.parameters.NEURON_TYPE == "LSTM": if self.parameters.EXP_REPLAY_ENABLED: if self.parameters.PRIORITIZED_EXP_REPLAY_ENABLED: return self.valueNetwork.train_on_batch( inputs, targets, sample_weight=importance_weights) else: return self.valueNetwork.train_on_batch(inputs, targets) else: return self.valueNetwork.train_on_batch( numpy.array([numpy.array([inputs])]), numpy.array([numpy.array([targets])])) else: if self.parameters.PRIORITIZED_EXP_REPLAY_ENABLED: return self.valueNetwork.train_on_batch( inputs, targets, sample_weight=importance_weights) else: return self.valueNetwork.train_on_batch(inputs, targets) def updateActionNetwork(self): self.actionNetwork.set_weights(self.valueNetwork.get_weights()) def updateTargetNetwork(self): self.targetNetwork.set_weights(self.valueNetwork.get_weights()) if __debug__: print("Target Network updated.") def predict(self, state, batch_len=1): if self.parameters.NEURON_TYPE == "LSTM": if self.parameters.EXP_REPLAY_ENABLED: return self.valueNetwork.predict(state, batch_size=batch_len) else: return self.valueNetwork.predict( numpy.array([numpy.array([state])]))[0][0] if self.parameters.CNN_REPR: state = numpy.array([state]) with self.graph.as_default(): prediction = self.valueNetwork.predict(state)[0] return prediction def predictTargetQValues(self, state): if self.parameters.USE_ACTION_AS_INPUT: return [ self.predict_target_network( numpy.array([numpy.concatenate((state[0], act))]))[0] for act in self.actions ] else: return self.predict_target_network(state) def predict_target_network(self, state, batch_len=1): if self.parameters.NEURON_TYPE == "LSTM": if self.parameters.EXP_REPLAY_ENABLED: return self.targetNetwork.predict(state, batch_size=batch_len) else: return self.targetNetwork.predict( numpy.array([numpy.array([state])]))[0][0] if self.parameters.CNN_REPR: state = numpy.array([state]) return self.targetNetwork.predict(state)[0] else: return self.targetNetwork.predict(state)[0] def predict_action_network(self, trace): return self.actionNetwork.predict(numpy.array([numpy.array([trace]) ]))[0] def predict_action(self, state): if self.parameters.USE_ACTION_AS_INPUT: return [ self.predict(numpy.array([numpy.concatenate( (state[0], act))]))[0] for act in self.actions ] else: if self.parameters.NEURON_TYPE == "MLP": return self.predict(state) else: return self.predict_action_network(state) def saveModel(self, path, name=""): if not os.path.exists(path + "models/"): os.mkdir(path + "models/") self.targetNetwork.set_weights(self.valueNetwork.get_weights()) complete = False while not complete: try: self.targetNetwork.save(path + "models/" + name + "model.h5") complete = True except Exception: print("Error saving network. ########################") complete = False print("Trying to save again...") def setEpsilon(self, val): self.epsilon = val def setFrameSkipRate(self, value): self.frameSkipRate = value def getParameters(self): return self.parameters def getNumOfActions(self): return self.num_actions def getEpsilon(self): return self.epsilon def getDiscount(self): return self.discount def getFrameSkipRate(self): return self.frameSkipRate def getGridSquaresPerFov(self): return self.gridSquaresPerFov def getStateReprLen(self): return self.stateReprLen def getNumActions(self): return self.num_actions def getLearningRate(self): return self.learningRate def getActivationFuncHidden(self): return self.activationFuncHidden def getActivationFuncOutput(self): return self.activationFuncOutput def getOptimizer(self): return self.optimizer def getActions(self): return self.actions def getTargetNetwork(self): return self.targetNetwork def getValueNetwork(self): return self.valueNetwork
model = Activation('relu')(model) model = BatchNormalization()(model) model = Dropout(0.2)(model) model = Dense(28)(model) model = Activation('relu')(model) model = BatchNormalization()(model) model = Dense(1)(model) model = Activation('sigmoid')(model) model = Model(inp, model) model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.fit(x_train, Y_train, batch_size=16, epochs=10) score = model.evaluate(x_test, Y_test, batch_size=16) print x_test y_pred = model.predict(x_test, batch_size=64) Y_pred = [] print y_pred for i in range(0,len(y_pred)): if y_pred[i][0] >= y_pred[i][1]: a = 1
train_directory = "../../Dermatologist_Dataset/data/train/" test_directory = "../../Dermatologist_Dataset/data/test/" validation_directory = "../../Dermatologist_Dataset/data/valid/" xception = Xception(weights="imagenet", include_top = False, input_shape=(224,224,3)) model = xception.output model = Flatten()(model) model = Dense(256, activation='relu', input_dim=7 * 7 * 512)(model) model = Dropout(0.5)(model) output_ = Dense(3, activation='softmax')(model) model = Model(inputs = xception.input, outputs = output_) model.compile(loss="categorical_crossentropy", optimizer = 'adam', metrics=["accuracy"]) from keras.preprocessing.image import ImageDataGenerator datagen = ImageDataGenerator(rescale=1./255) batch_size = 20 train_generator = datagen.flow_from_directory( train_directory, target_size=(224, 224), batch_size=batch_size, class_mode='categorical', shuffle="True") test_datagen = ImageDataGenerator(rescale = 1./255) test_set = test_datagen.flow_from_directory(test_directory,
# model.add(Activation('tanh')) # model.add(Dropout(0.5)) # model.add(Dense(hidden2)) #Full connection 2: 200 # model.add(Activation('tanh')) # model.add(Dropout(0.5)) model=Dense(nb_classes)(model) model=Activation('softmax')(model) # model.summary() model = Model(input=[l1_input], output=[model]) model.summary() # quit() sgd = SGD(lr=lr, decay=decay, momentum=momentum, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=["accuracy"]) # # 3. 第一层卷积层:多size卷积层(含1-max pooling),使用三种size. # m1= Sequential() # m1.add(Convolution2D(8,2,1293,input_shape=l2_reshape_output_shape)) # m2= Sequential() # m2.add(Convolution2D(8,3,1293,input_shape=l2_reshape_output_shape)) # m3= Sequential() # m3.add(Convolution2D(8,4,1293,input_shape=l2_reshape_output_shape)) # seq = Sequential() # seq.add(Merge([m1,m2,m3],mode='concat',concat_axis=2)) # # seq.summary() # # quit() # l3 = seq([l2_reshape,l2_reshape,l2_reshape]) # # l3_cnn_model = Dropout(0.5)(l3_cnn_model) # # print(l3_cnn_model_out_shape) # #
print('Model loaded') except: # Build the model to be trained X_train = get_evaluated(X_train, 'train_{}'.format(args.augment), BATCH_SIZE) X_valid = get_evaluated(X_valid, 'valid', BATCH_SIZE) inputs = Input(shape=X_train[0].shape) model = Flatten()(inputs) model = Dense(384, activation='relu')(model) model = Dropout(0.5)(model) model = Dense(128, activation='relu')(model) model = Dropout(0.5)(model) model = Dense(10, activation='softmax')(model) model = Model(inputs=inputs, outputs=model) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) print(model.summary()) # Training callbacks callbacks = [ EarlyStopping(patience=10), TensorBoard(log_dir='output/logs_{}'.format(FILENAME)), ModelCheckpoint(filepath='output/{}.h5'.format(FILENAME), save_best_only=True), ] # Run training print('Training model') model.fit(x=X_train, y=y_train, batch_size=BATCH_SIZE, validation_data=(X_valid, y_valid),
def scratchVGG16_Model(): data = helper.prepDataforCNN(numChannel=3, feat_norm=True) trainX = data["trainX"] valdX = data["valdX"] trainY = data["trainY"] valdY = data["valdY"] _, row, col, channel = trainX.shape digLen = 5 # including category 0 numDigits = 11 epochs = 50 batch_size = 64 vgg16Model = VGG16(include_top=False, weights=None) vgg16Model.summary() ptInput = keras.Input(shape=(row, col, channel), name='vgg16Scratch') vgg16 = vgg16Model(ptInput) # vgg16 = Conv2D(64,(3, 3), activation ='relu', padding='same')(input) # vgg16 = Conv2D(64,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = MaxPooling2D(pool_size=(2, 2))(vgg16) # # vgg16 = Conv2D(128,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = Conv2D(128,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = MaxPooling2D(pool_size=(2, 2))(vgg16) # # vgg16 = Conv2D(256,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = Conv2D(256,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = MaxPooling2D(pool_size=(2, 2))(vgg16) # # vgg16 = Conv2D(512,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = Conv2D(512,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = Conv2D(512,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = MaxPooling2D(pool_size=(2, 2))(vgg16) # # vgg16 = Conv2D(512,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = Conv2D(512,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = Conv2D(512,(3, 3), activation ='relu', padding='same')(vgg16) # vgg16 = MaxPooling2D(pool_size=(2, 2))(vgg16) vgg16 = Flatten()(vgg16) vgg16 = Dense(512, activation='relu')(vgg16) vgg16 = Dense(512, activation='relu')(vgg16) # vgg16 = Dense(1000, activation='relu')(vgg16) vgg16 = Dropout(0.5)(vgg16) numd_SM = Dense(digLen, activation='softmax', name='num')(vgg16) dig1_SM = Dense(numDigits, activation='softmax', name='dig1')(vgg16) dig2_SM = Dense(numDigits, activation='softmax', name='dig2')(vgg16) dig3_SM = Dense(numDigits, activation='softmax', name='dig3')(vgg16) dig4_SM = Dense(numDigits, activation='softmax', name='dig4')(vgg16) numB_SM = Dense(2, activation='softmax', name='nC')(vgg16) out = [numd_SM, dig1_SM, dig2_SM, dig3_SM, dig4_SM, numB_SM] vgg16 = keras.Model(inputs=ptInput, outputs=out) callback = [] optim = optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=True) checkpointer = keras.callbacks.ModelCheckpoint( filepath='saved_models/vgg16.classifier.hdf5', monitor='loss', save_best_only=True, verbose=2) reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=0.1, verbose=1, patience=3, cooldown=0, min_lr=0.000001) # tb = keras.callbacks.TensorBoard(log_dir='logs', write_graph=True, write_images=True) es = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0.00000001, patience=5, verbose=1, mode='auto') callback.append(es) callback.append(checkpointer) callback.append(reduce_lr) vgg16.summary() vgg16.compile(loss='sparse_categorical_crossentropy', optimizer=optim, metrics=['accuracy']) vgg16History = vgg16.fit(x=trainX, y=trainY, batch_size=batch_size, epochs=epochs, verbose=1, shuffle=True, validation_data=(valdX, valdY), callbacks=callback) print(vgg16History.history.keys()) modName = 'vgg16_Scratch' print(vgg16History.history.keys()) createSaveMetricsPlot(vgg16History, modName, data, vgg16)
from keras.models import Sequential, Input, Model from keras.layers import Dense, Dropout, Conv2D, Flatten from keras.constraints import unit_norm from keras.optimizers import Adam """implementing Convolutional Neural Network""" model_conv_input = Input(shape=(90, 13, 1)) model_conv = Conv2D(filters=20, kernel_size=(10,10), strides=(6,6), padding='same', activation='sigmoid')(model_conv_input) # model_conv = Conv2D(filters=16, kernel_size=(5,5), strides=(4,4), # padding='same', activation='sigmoid')(model_conv) model_conv = Flatten()(model_conv) model_conv = Dense(units=128, activation='relu')(model_conv) model_conv = Dense(units=64, activation='relu')(model_conv) model_conv = Dropout(0.3)(model_conv) model_conv = Dense(units=10, activation='softmax')(model_conv) model_conv = Model(inputs=model_conv_input, output=model_conv) model_conv.summary() adam = Adam(lr = 0.001) model_conv.compile(loss='categorical_crossentropy', optimizer = adam, metrics=['accuracy']) model_conv.save('model_conv_untrained.h5')
def vgg16(classes, epochs, steps_per_epoch, validation_steps, input_shape): # 加载数据 train_batches, valid_batches = load_data(input_shape) input_shape += (3, ) model_vgg = keras.applications.vgg16.VGG16(include_top=False, weights='imagenet', input_shape=input_shape) for layer in model_vgg.layers: layer.trainable = False # 别去调整之前的卷积层的参数 model = Flatten(name='flatten')(model_vgg.output) # 去掉全连接层,前面都是卷积层 model = Dense(256, activation='relu', name='fc1')(model) model = Dense(256, activation='relu', name='fc2')(model) model = Dropout(0.5)(model) # model = Dropout(0.6)(model) if classes == 1: print("二元分类") model = Dense(classes, activation='sigmoid')(model) # model就是最后的y model = Model(inputs=model_vgg.input, outputs=model, name='vgg16') ada = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) model.compile(loss='binary_crossentropy', optimizer=ada, metrics=['accuracy']) else: print("多分类") model = Dense(classes, activation='softmax')(model) # model就是最后的y model = Model(inputs=model_vgg.input, outputs=model, name='vgg16') ada = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) model.compile(loss='categorical_crossentropy', optimizer=ada, metrics=['accuracy']) #保存模型 out_dir = "../weights/" if not os.path.exists(out_dir): os.makedirs(out_dir) filepath = "../weights/vgg16_{epoch:04d}.h5" # 中途训练效果提升, 则将文件保存, 每提升一次, 保存一次 checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=0, save_best_only=False, mode='max') #学习率调整 lr_reduce = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, verbose=1, min_lr=0.00000001, mode="min") # 早停 earlystopping = EarlyStopping(monitor='val_loss', patience=15, verbose=1, mode='min') #保存训练过程 log_dir = "../logs/" if not os.path.exists(log_dir): os.makedirs(log_dir) logfile = "../logs/vgg16.csv" log = keras.callbacks.CSVLogger(logfile, separator=',', append=False) loggraph = keras.callbacks.TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=True) callbacks_list = [checkpoint, lr_reduce, log, earlystopping] # 训练 model.fit_generator(train_batches, steps_per_epoch=steps_per_epoch, validation_data=valid_batches, validation_steps=validation_steps, epochs=epochs, verbose=2, callbacks=callbacks_list, workers=16, max_queue_size=20)
model) #This will apply the dense layer on top of the flatten layer model = Dense(4096, activation='relu', name='fc2')( model) #This will apply the dense layer on top of the previous layer model = Dense(numClasses, activation='softmax', name='outputs')( model) #This is for the final layer of size number of classes model = Model( base_model.input, model ) #This will take the nase model input and concatenate the model we have created #Freezing the initial 16 layers so that it doesn't get used during training for i in model.layers[:16]: i.trainable = False #it sets the hyperparmaters model.compile(loss='categorical_crossentropy', optimizer='adam') print("Model Created") tfBoard = TensorBoard(log_dir="./logs") X, y = load_data_full("./data", numClasses) #Data augmentation to get more photos from existing photos datagen = ImageDataGenerator(rotation_range=50, horizontal_flip=True, shear_range=0.2, fill_mode='nearest') datagen.fit(X) print("Starting Training") model.fit_generator(datagen.flow(X, y, batch_size=3), steps_per_epoch=len(X) / 3,
nb_col=3, activation='relu', border_mode='same')(model) model = MaxPooling2D(pool_size=(2, 2), border_mode='valid')(model) #model = Convolution2D(nb_filter = 20, nb_row=3, nb_col=3, activation='relu', border_mode='same')(model) #model = MaxPooling2D(pool_size=(2,2), border_mode='valid')(model) model = Flatten()(model) model = Dense(output_dim=50)(model) #model = Dropout(0.95)(model) #model = Dense(output_dim=60)(model) #model = Dropout(0.9)(model) model = Dense(output_dim=30)(model) model = Model(input=input, output=model) model.compile(optimizer='Adadelta', loss='mean_squared_error', metrics=['mean_squared_error']) #========================================== # Train Model #========================================== batch_size = 10 epochs = 10000 angles = [0, 30, -30, 45, -45, 60, -60, 90, -90] for epoch in range(0, epochs): data_batch, label_batch = dt.get_batch(images, labels, batch_size) for ind in range(0, len(data_batch)): rotation = angles[dt.np.random.randint(len(angles))] data_batch[ind] = dt.rotate_image(data_batch[ind],
model = Net() top_model = model.output # top_model = Dropout(0.2, name='drop9')(top_model) top_model = Flatten()(top_model) top_model = Dense(600)(top_model) top_model = BatchNormalization()(top_model) top_model = Activation('relu', name='relu_conv9')(top_model) # top_model = Dense(600)(top_model) # top_model = Activation('relu', name='relu_conv10')(top_model) top_model = Dense(10)(top_model) top_model = BatchNormalization()(top_model) top_model = Activation('softmax', name='loss')(top_model) top_model = Model(model.input, top_model, name='top_net') #設定model參數 top_model.compile(loss=keras.losses.categorical_crossentropy, optimizer='adam', metrics=['accuracy']) #process data def load_data(): # load data (X_train, y_train), (X_test, y_test) = mnist.load_data() # normalize inputs from 0-255 to 0-1 X_train = X_train / 255 X_test = X_test / 255 # one hot encode outputs y_train = np_utils.to_categorical(y_train, classes) y_test = np_utils.to_categorical(y_test, classes) return (X_train, y_train), (X_test, y_test)
generator = UpSampling2D(3)(generator) generator = Conv2D(30, 5, padding="same", activation="relu")(generator) generator = Dropout(.25)(generator) generator = UpSampling2D(2)(generator) generator = Conv2D(20, 7, padding="same", activation="relu")(generator) generator = Dropout(.25)(generator) generator = Conv2D(4, 4, padding="same", activation="sigmoid")(generator) generator = Model(inputLayer, generator) generator.compile(loss='binary_crossentropy', optimizer="adam") print(generator.summary()) print("generator constructed...") generator.save("generator") print("generator saved.") inputLayer = Input(shape=(96, 96, 4)) discriminator = Conv2D(8, 5, padding="same", activation="relu")(inputLayer) discriminator = Flatten()(discriminator) discriminator = Dense(32, activation="relu")(discriminator) discriminator = Dropout(.25)(discriminator) discriminator = Dense(1, activation='sigmoid')(discriminator) discriminator = Model(inputLayer, discriminator) discriminator.compile(loss='binary_crossentropy', optimizer="adam") print(discriminator.summary()) print("discriminator constructed...") discriminator.save("discriminator") print("discriminator saved")
input_shape=(IM_WIDTH, IM_HEIGHT, 3)) model = model_inception(Input_layer) model = Flatten()(model) #model = Dense(32)(model) model = Dense(2)(model) model = Activation('softmax')(model) model = Model(Input_layer, model) for layer in model_inception.layers: layer.trainable = False early_stop = EarlyStopping(monitor='val_loss', patience=3, verbose=1) best_model = ModelCheckpoint('MobileNetModel_4.h5', verbose=1, save_best_only=True) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() with tensorflow.device('/device:XLA_GPU:0'): train_log = model.fit_generator( train_generator, validation_data=val_generator, steps_per_epoch=train_generator.n / batch_size, validation_steps=val_generator.n / batch_size, epochs=EPOCH, callbacks=[ TensorBoard(log_dir='mytensorboard2'), best_model, early_stop ]) loss, acc = model.evaluate_generator(test_generator, steps=32) print('Test result:loss:%f,acc:%f' % (loss, acc)) A = model.predict_generator(test_generator, steps=16)
class Network(object): def __init__(self, parameters, modelName=None): self.parameters = parameters if parameters.SQUARE_ACTIONS: self.actions = createDiscreteActionsSquare( self.parameters.NUM_ACTIONS, self.parameters.ENABLE_SPLIT, self.parameters.ENABLE_EJECT) else: self.actions = createDiscreteActionsCircle( self.parameters.NUM_ACTIONS, self.parameters.ENABLE_SPLIT, self.parameters.ENABLE_EJECT) self.num_actions = len(self.actions) self.loadedModelName = None self.gpus = self.parameters.GPUS # Q-learning self.discount = self.parameters.DISCOUNT self.epsilon = self.parameters.EPSILON self.frameSkipRate = self.parameters.FRAME_SKIP_RATE self.gridSquaresPerFov = self.parameters.GRID_SQUARES_PER_FOV # CNN if self.parameters.CNN_REPR: # (KernelSize, stride, filterNum) self.kernel_1 = self.parameters.CNN_L1 self.kernel_2 = self.parameters.CNN_L2 self.kernel_3 = self.parameters.CNN_L3 if self.parameters.CNN_USE_L1: self.stateReprLen = self.parameters.CNN_INPUT_DIM_1 elif self.parameters.CNN_USE_L2: self.stateReprLen = self.parameters.CNN_INPUT_DIM_2 else: self.stateReprLen = self.parameters.CNN_INPUT_DIM_3 else: self.stateReprLen = self.parameters.STATE_REPR_LEN # ANN self.learningRate = self.parameters.ALPHA self.optimizer = self.parameters.OPTIMIZER if self.parameters.ACTIVATION_FUNC_HIDDEN == "elu": self.activationFuncHidden = "linear" # keras.layers.ELU(alpha=eluAlpha) else: self.activationFuncHidden = self.parameters.ACTIVATION_FUNC_HIDDEN self.activationFuncLSTM = self.parameters.ACTIVATION_FUNC_LSTM self.activationFuncOutput = self.parameters.ACTIVATION_FUNC_OUTPUT self.layers = parameters.Q_LAYERS if self.parameters.USE_ACTION_AS_INPUT: inputDim = self.stateReprLen + 4 outputDim = 1 else: inputDim = self.stateReprLen outputDim = self.num_actions if self.parameters.EXP_REPLAY_ENABLED: input_shape_lstm = (self.parameters.MEMORY_TRACE_LEN, inputDim) stateful_training = False self.batch_len = self.parameters.MEMORY_BATCH_LEN else: input_shape_lstm = (1, inputDim) stateful_training = True self.batch_len = 1 if self.parameters.INITIALIZER == "glorot_uniform": initializer = keras.initializers.glorot_uniform() elif self.parameters.INITIALIZER == "glorot_normal": initializer = keras.initializers.glorot_normal() else: weight_initializer_range = math.sqrt( 6 / (self.stateReprLen + self.num_actions)) initializer = keras.initializers.RandomUniform( minval=-weight_initializer_range, maxval=weight_initializer_range, seed=None) # CNN if self.parameters.CNN_REPR: if self.parameters.CNN_P_REPR: if self.parameters.CNN_P_INCEPTION: self.input = Input(shape=(self.stateReprLen, self.stateReprLen, 3)) tower_1 = Conv2D(self.kernel_2[2], (1, 1), padding='same', activation='relu')(self.input) tower_1 = Conv2D(self.kernel_2[2], (3, 3), padding='same', activation='relu')(tower_1) tower_2 = Conv2D(self.kernel_2[2], (1, 1), padding='same', activation='relu')(self.input) tower_2 = Conv2D(self.kernel_2[2], (5, 5), padding='same', activation='relu')(tower_2) tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(self.input) tower_3 = Conv2D(self.kernel_2[2], (1, 1), padding='same', activation='relu')(tower_3) self.valueNetwork = keras.layers.concatenate( [tower_1, tower_2, tower_3], axis=3) self.valueNetwork = keras.layers.Flatten()( self.valueNetwork) # DQN approach else: # RGB if self.parameters.CNN_P_RGB: channels = 3 # GrayScale else: channels = 1 if self.parameters.CNN_LAST_GRID: channels = channels * 2 if self.parameters.COORDCONV: channels += 2 self.input = Input(shape=(self.stateReprLen, self.stateReprLen, channels)) conv = self.input if self.parameters.CNN_USE_L1: conv = Conv2D(self.kernel_1[2], kernel_size=(self.kernel_1[0], self.kernel_1[0]), strides=(self.kernel_1[1], self.kernel_1[1]), activation='relu', data_format='channels_last')(conv) if self.parameters.CNN_USE_L2: conv = Conv2D(self.kernel_2[2], kernel_size=(self.kernel_2[0], self.kernel_2[0]), strides=(self.kernel_2[1], self.kernel_2[1]), activation='relu', data_format='channels_last')(conv) if self.parameters.CNN_USE_L3: conv = Conv2D(self.kernel_3[2], kernel_size=(self.kernel_3[0], self.kernel_3[0]), strides=(self.kernel_3[1], self.kernel_3[1]), activation='relu', data_format='channels_last')(conv) self.valueNetwork = Flatten()(conv) # Not pixel input else: if self.parameters.CNN_TOWER: tower = [] self.input = [] self.towerModel = [] for grid in range(self.parameters.NUM_OF_GRIDS): self.input.append( Input(shape=(1, self.stateReprLen, self.stateReprLen))) if self.parameters.CNN_USE_L1: tower.append( Conv2D(self.kernel_1[2], kernel_size=(self.kernel_1[0], self.kernel_1[0]), strides=(self.kernel_1[1], self.kernel_1[1]), activation='relu', data_format='channels_first')( self.input[grid])) if self.parameters.CNN_USE_L2: if self.parameters.CNN_USE_L1: tower[grid] = Conv2D( self.kernel_2[2], kernel_size=(self.kernel_2[0], self.kernel_2[0]), strides=(self.kernel_2[1], self.kernel_2[1]), activation='relu', data_format='channels_first')(tower[grid]) else: tower.append( Conv2D(self.kernel_2[2], kernel_size=(self.kernel_2[0], self.kernel_2[0]), strides=(self.kernel_2[1], self.kernel_2[1]), activation='relu', data_format='channels_first')( self.input[grid])) if self.parameters.CNN_USE_L3: if self.parameters.CNN_USE_L2: tower[grid] = Conv2D( self.kernel_3[2], kernel_size=(self.kernel_3[0], self.kernel_3[0]), strides=(self.kernel_3[1], self.kernel_3[1]), activation='relu', data_format='channels_first')(tower[grid]) else: tower.append( Conv2D(self.kernel_3[2], kernel_size=(self.kernel_3[0], self.kernel_3[0]), strides=(self.kernel_3[1], self.kernel_3[1]), activation='relu', data_format='channels_first')( self.input[grid])) tower[grid] = Flatten()(tower[grid]) self.valueNetwork = keras.layers.concatenate( [i for i in tower], axis=1) # Vision grid merging else: self.input = Input(shape=(self.parameters.NUM_OF_GRIDS, self.stateReprLen, self.stateReprLen)) conv = self.input if self.parameters.CNN_USE_L1: conv = Conv2D(self.kernel_1[2], kernel_size=(self.kernel_1[0], self.kernel_1[0]), strides=(self.kernel_1[1], self.kernel_1[1]), activation='relu', data_format='channels_first')(conv) if self.parameters.CNN_USE_L2: conv = Conv2D(self.kernel_2[2], kernel_size=(self.kernel_2[0], self.kernel_2[0]), strides=(self.kernel_2[1], self.kernel_2[1]), activation='relu', data_format='channels_first')(conv) if self.parameters.CNN_USE_L3: conv = Conv2D(self.kernel_3[2], kernel_size=(self.kernel_3[0], self.kernel_3[0]), strides=(self.kernel_3[1], self.kernel_3[1]), activation='relu', data_format='channels_first')(conv) self.valueNetwork = Flatten()(conv) # Fully connected layers if self.parameters.NEURON_TYPE == "MLP": layerIterable = iter(self.layers) regularizer = keras.regularizers.l2(self.parameters.Q_WEIGHT_DECAY) if self.parameters.DROPOUT: constraint = maxnorm(self.parameters.MAXNORM) else: constraint = None if parameters.CNN_REPR: previousLayer = self.input extraInputSize = self.parameters.EXTRA_INPUT if extraInputSize > 0: extraInput = Input(shape=(extraInputSize, )) self.input = [self.input, extraInput] denseInput = keras.layers.concatenate( [self.valueNetwork, extraInput]) previousLayer = Dense( next(layerIterable), activation=self.activationFuncHidden, bias_initializer=initializer, kernel_initializer=initializer, kernel_regularizer=regularizer)(denseInput) else: self.input = Input(shape=(inputDim, )) previousLayer = self.input for layer in layerIterable: if layer > 0: if self.parameters.DROPOUT: previousLayer = Dropout( self.parameters.DROPOUT)(previousLayer) previousLayer = Dense( layer, activation=self.activationFuncHidden, bias_initializer=initializer, kernel_initializer=initializer, kernel_regularizer=regularizer, kernel_constraint=constraint)(previousLayer) if self.parameters.ACTIVATION_FUNC_HIDDEN == "elu": previousLayer = (keras.layers.ELU( alpha=self.parameters.ELU_ALPHA))(previousLayer) if self.parameters.BATCHNORM: previousLayer = BatchNormalization()(previousLayer) if self.parameters.DROPOUT: previousLayer = Dropout(self.parameters.DROPOUT)(previousLayer) output = Dense(outputDim, activation=self.activationFuncOutput, bias_initializer=initializer, kernel_initializer=initializer, kernel_regularizer=regularizer, kernel_constraint=constraint)(previousLayer) self.valueNetwork = keras.models.Model(inputs=self.input, outputs=output) elif self.parameters.NEURON_TYPE == "LSTM": # Hidden Layer 1 # TODO: Use CNN with LSTM # if self.parameters.CNN_REPR: # hidden1 = LSTM(self.hiddenLayer1, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len) # else: # hidden1 = LSTM(self.hiddenLayer1, input_shape=input_shape_lstm, return_sequences = True, # stateful= stateful_training, batch_size=self.batch_len) hidden1 = LSTM(self.hiddenLayer1, input_shape=input_shape_lstm, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.valueNetwork.add(hidden1) # Hidden 2 if self.hiddenLayer2 > 0: hidden2 = LSTM(self.hiddenLayer2, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.valueNetwork.add(hidden2) # Hidden 3 if self.hiddenLayer3 > 0: hidden3 = LSTM(self.hiddenLayer3, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.valueNetwork.add(hidden3) # Output layer output = LSTM(outputDim, activation=self.activationFuncOutput, return_sequences=True, stateful=stateful_training, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.valueNetwork.add(output) # Create target network self.targetNetwork = keras.models.clone_model(self.valueNetwork) self.targetNetwork.set_weights(self.valueNetwork.get_weights()) if self.parameters.OPTIMIZER == "Adam": if self.parameters.GRADIENT_CLIP_NORM: optimizer = keras.optimizers.Adam( lr=self.learningRate, clipnorm=self.parameters.GRADIENT_CLIP_NORM, amsgrad=self.parameters.AMSGRAD) elif self.parameters.GRADIENT_CLIP: optimizer = keras.optimizers.Adam( lr=self.learningRate, clipvalue=self.parameters.GRADIENT_CLIP, amsgrad=self.parameters.AMSGRAD) else: optimizer = keras.optimizers.Adam( lr=self.learningRate, amsgrad=self.parameters.AMSGRAD) elif self.parameters.OPTIMIZER == "Nadam": optimizer = keras.optimizers.Nadam(lr=self.learningRate) elif self.parameters.OPTIMIZER == "Adamax": optimizer = keras.optimizers.Adamax(lr=self.learningRate) elif self.parameters.OPTIMIZER == "SGD": if self.parameters.NESTEROV: optimizer = keras.optimizers.SGD( lr=self.learningRate, momentum=self.parameters.NESTEROV, nesterov=True) else: optimizer = keras.optimizers.SGD(lr=self.learningRate) self.optimizer = optimizer self.valueNetwork.compile(loss='mse', optimizer=optimizer) self.targetNetwork.compile(loss='mse', optimizer=optimizer) self.model = self.valueNetwork if self.parameters.NEURON_TYPE == "LSTM": # We predict using only one state input_shape_lstm = (1, self.stateReprLen) self.actionNetwork = Sequential() hidden1 = LSTM(self.hiddenLayer1, input_shape=input_shape_lstm, return_sequences=True, stateful=True, batch_size=1, bias_initializer=initializer, kernel_initializer=initializer) self.actionNetwork.add(hidden1) if self.hiddenLayer2 > 0: hidden2 = LSTM(self.hiddenLayer2, return_sequences=True, stateful=True, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.actionNetwork.add(hidden2) if self.hiddenLayer3 > 0: hidden3 = LSTM(self.hiddenLayer3, return_sequences=True, stateful=True, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer) self.actionNetwork.add(hidden3) self.actionNetwork.add( LSTM(self.num_actions, activation=self.activationFuncOutput, return_sequences=False, stateful=True, batch_size=self.batch_len, bias_initializer=initializer, kernel_initializer=initializer)) self.actionNetwork.compile(loss='mse', optimizer=optimizer) print(self.valueNetwork.summary()) print("\n") if modelName is not None: self.load(modelName) def reset_general(self, model): session = K.get_session() for layer in model.layers: for v in layer.__dict__: v_arg = getattr(layer, v) if hasattr(v_arg, 'initializer'): initializer_method = getattr(v_arg, 'initializer') initializer_method.run(session=session) print('reinitializing layer {}.{}'.format(layer.name, v)) def reset_weights(self): self.reset_general(self.valueNetwork) self.reset_general(self.targetNetwork) def reset_hidden_states(self): self.actionNetwork.reset_states() self.valueNetwork.reset_states() self.targetNetwork.reset_states() def load(self, modelName): path = modelName self.loadedModelName = modelName self.valueNetwork = keras.models.load_model(path + "model.h5") self.targetNetwork = load_model(path + "model.h5") def trainOnBatch(self, inputs, targets, importance_weights): if self.parameters.NEURON_TYPE == "LSTM": if self.parameters.EXP_REPLAY_ENABLED: if self.parameters.PRIORITIZED_EXP_REPLAY_ENABLED: return self.valueNetwork.train_on_batch( inputs, targets, sample_weight=importance_weights) else: return self.valueNetwork.train_on_batch(inputs, targets) else: return self.valueNetwork.train_on_batch( numpy.array([numpy.array([inputs])]), numpy.array([numpy.array([targets])])) else: if self.parameters.PRIORITIZED_EXP_REPLAY_ENABLED: return self.valueNetwork.train_on_batch( inputs, targets, sample_weight=importance_weights) else: return self.valueNetwork.train_on_batch(inputs, targets) def updateActionNetwork(self): self.actionNetwork.set_weights(self.valueNetwork.get_weights()) def updateTargetNetwork(self): self.targetNetwork.set_weights(self.valueNetwork.get_weights()) def predict(self, state, batch_len=1): if self.parameters.NEURON_TYPE == "LSTM": if self.parameters.EXP_REPLAY_ENABLED: return self.valueNetwork.predict(state, batch_size=batch_len) else: return self.valueNetwork.predict( numpy.array([numpy.array([state])]))[0][0] if self.parameters.CNN_REPR: if self.parameters.CNN_TOWER: stateRepr = numpy.zeros( (len(state), 1, 1, len(state[0]), len(state[0]))) for gridIdx, grid in enumerate(state): stateRepr[gridIdx][0][0] = grid state = list(stateRepr) else: if len(state) == 2: grid = numpy.array([state[0]]) extra = numpy.array([state[1]]) state = [grid, extra] else: state = numpy.array([state]) return self.valueNetwork.predict(state)[0] def predictTargetQValues(self, state): if self.parameters.USE_ACTION_AS_INPUT: return [ self.predict_target_network( numpy.array([numpy.concatenate((state[0], act))]))[0] for act in self.actions ] else: return self.predict_target_network(state) def predict_target_network(self, state, batch_len=1): if self.parameters.NEURON_TYPE == "LSTM": if self.parameters.EXP_REPLAY_ENABLED: return self.targetNetwork.predict(state, batch_size=batch_len) else: return self.targetNetwork.predict( numpy.array([numpy.array([state])]))[0][0] if self.parameters.CNN_REPR: if self.parameters.CNN_TOWER: stateRepr = numpy.zeros( (len(state), 1, 1, len(state[0]), len(state[0]))) for gridIdx, grid in enumerate(state): stateRepr[gridIdx][0][0] = grid stateRepr = list(stateRepr) return self.targetNetwork.predict(stateRepr)[0] else: if len(state) == 2: grid = numpy.array([state[0]]) extra = numpy.array([state[1]]) state = [grid, extra] else: state = numpy.array([state]) return self.targetNetwork.predict(state)[0] else: return self.targetNetwork.predict(state)[0] def predict_action_network(self, trace): return self.actionNetwork.predict(numpy.array([numpy.array([trace]) ]))[0] def predict_action(self, state): if self.parameters.USE_ACTION_AS_INPUT: return [ self.predict(numpy.array([numpy.concatenate( (state[0], act))]))[0] for act in self.actions ] else: if self.parameters.NEURON_TYPE == "MLP": return self.predict(state) else: return self.predict_action_network(state) def saveModel(self, path, name=""): self.targetNetwork.set_weights(self.valueNetwork.get_weights()) self.targetNetwork.save(path + name + "model.h5") def setEpsilon(self, val): self.epsilon = val def setFrameSkipRate(self, value): self.frameSkipRate = value def getParameters(self): return self.parameters def getNumOfActions(self): return self.num_actions def getEpsilon(self): return self.epsilon def getDiscount(self): return self.discount def getFrameSkipRate(self): return self.frameSkipRate def getGridSquaresPerFov(self): return self.gridSquaresPerFov def getTargetNetworkMaxSteps(self): return self.targetNetworkMaxSteps def getStateReprLen(self): return self.stateReprLen def getHiddenLayer1(self): return self.hiddenLayer1 def getHiddenLayer2(self): return self.hiddenLayer2 def getHiddenLayer3(self): return self.hiddenLayer3 def getNumActions(self): return self.num_actions def getLearningRate(self): return self.learningRate def getActivationFuncHidden(self): return self.activationFuncHidden def getActivationFuncOutput(self): return self.activationFuncOutput def getOptimizer(self): return self.optimizer def getLoadedModelName(self): return self.loadedModelName def getActions(self): return self.actions def getTargetNetwork(self): return self.targetNetwork def getValueNetwork(self): return self.valueNetwork