def Model_(): input = Input(shape=(48, 48, 1)) #model = Lambda(lambda image: tf.image.resize(image, target_size))(input) model = Conv2D(64, (2, 2), strides=1, activation='relu', padding='valid')(input) model = Conv2D(64, (2, 2), strides=1, activation='relu', padding='valid')(model) model = MaxPooling2D((2, 2), strides=2, padding='valid')(model) model = Conv2D(128, (3, 3), strides=1, activation='relu', padding='valid')(model) model = Conv2D(128, (3, 3), strides=1, activation='relu', padding='valid')(model) model = Conv2D(128, (3, 3), strides=1, activation='relu', padding='valid')(model) model = MaxPooling2D((2, 2), strides=2, padding='valid')(model) model = Flatten()(model) model = Dense(2048, activation="relu")(model) model = Dense(1024, activation="relu")(model) model = Dropout(0.5)(model) out = Dense(7, activation="softmax")(model) model = Model(input, out) model.summary() 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 build(self, *args, trainedModel=None) -> Sequential: ''' THIS FUNCTION IS RESPONSIBLE FOR THE INITIALIZATION OF SEQUENTIAL ALEXNET MODEL :param args: list integers, in logical order --> to populate cnn (filters) and dense (neurons) :return: Sequential: AlexNet MODEL ''' try: #IF USER ALREADY HAVE A TRAINED MODEL, AND NO WANTS TO BUILD AGAIN A NEW MODEL if trainedModel != None: return trainedModel # definition of input shape and Input Layer input_shape = (config.WIDTH, config.HEIGHT, config.CHANNELS) input = Input(input_shape) ## add stack conv layer to the model numberFilters = args[1] model = None for i in range(args[0]): if i == 0: model = self.add_stack( input, numberFilters, 0.25, input_shape) # first stack convolution layer else: model = self.add_stack(model, numberFilters, 0.25) numberFilters += args[2] # flatten model = Flatten()(model) # Full Connected Layer(s) for i in range(args[3]): model = Dense(units=args[4], kernel_regularizer=regularizers.l2(config.DECAY), kernel_initializer='he_uniform')(model) model = Activation(config.RELU_FUNCTION)(model) model = BatchNormalization()(model) if i != (args[3] - 1): model = Dropout(0.25)( model ) ## applies Dropout on all FCL's except FCL preceding the ouput layer (softmax) # Output Layer model = Dense(units=config.NUMBER_CLASSES)(model) model = Activation(config.SOFTMAX_FUNCTION)(model) # build model model = mp(inputs=input, outputs=model) if config.BUILD_SUMMARY == 1: model.summary() return model except: raise CustomError.ErrorCreationModel(config.ERROR_ON_BUILD)
def create_discriminator(img_shape=(28, 28)): sequence = Input(shape=img_shape) model = Flatten()(sequence) model = Dense(512)(model) model = LeakyReLU(alpha=0.2)(model) model = Dense(256)(model) model = LeakyReLU(alpha=0.2)(model) output = Dense(1, activation='sigmoid')(model) model = Model(inputs=sequence, outputs=output) model.summary() return model
def build_class_model(input_shape): inputs = Input(shape=input_shape) model = Conv1D(32, kernel_size=1, padding='valid', activation='selu', kernel_initializer='lecun_normal')(inputs) model = Conv1D(32, kernel_size=1, padding='valid', activation='selu', kernel_initializer='lecun_normal')(model) model = Conv1D(64, kernel_size=1, padding='valid', activation='selu', kernel_initializer='lecun_normal')(model) model = Conv1D(128, kernel_size=1, padding='valid', activation='selu', kernel_initializer='lecun_normal')(model) model = Conv1D(128, kernel_size=input_shape[0], padding='valid', activation='selu', kernel_initializer='lecun_normal')(model) model = Flatten()(model) model = Dense(128, activation='selu', kernel_initializer='lecun_normal')(model) model = Dense(256, activation='selu', kernel_initializer='lecun_normal')(model) model = Dropout(0.3)(model) model = Dense(512, activation='selu', kernel_initializer='lecun_normal')(model) model = Dropout(0.4)(model) model = Dense(256, activation='selu', kernel_initializer='lecun_normal')(model) model = Dense(128, activation='selu', kernel_initializer='lecun_normal')(model) model = Dense(1, activation='selu')(model) model = Model(inputs, model) model.summary() return model
def build(self): """ Returns: An instance of the EmoPy VGG Face model """ # x = VGGFace(include_top=False, input_shape=self.input_shape) vgg_model = VGGFace(include_top=False, input_shape=(224, 224, 3)) last_layer = vgg_model.get_layer('pool5').output x = Flatten(name='flatten')(last_layer) x = Dense(32, activation='relu', name='fc6')(x) x = Dense(32, activation='relu', name='fc7')(x) print("VGG") x.summary() return vgg_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_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 _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=Flatten()(model) #平铺 # model.add(Dense(hidden1)) #Full connection 1: 1000 # 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])
# 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), epochs=1000, callbacks=callbacks)
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")
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')
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
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)