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