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)
