def build(self, input_shape):
input_dimension = input_shape[-1]
units1 = self.output_dimension * self.number_of_mixtures
self.mu_kernel = self.add_weight(name="mu_kernel",
shape = shape(input_dimension, units1),
initializer=initializers.random_normal(),
trainable=True)
self.mu_bias = self.add_weight(name="mu_bias",
shape = shape(units1),
initializer=initializers.zeros(),
trainable=True)
self.sigma_kernel = self.add_weight(name="sigma_kernel",
shape = shape(input_dimension, units1),
initializer=initializers.random_normal(),
trainable=True)
self.sigma_bias = self.add_weight(name="sigma_bias",
shape = shape(units1),
initializer=initializers.zeros(),
trainable=True)
units2 = self.number_of_mixtures
self.pi_kernel = self.add_weight(name="pi_kernel",
shape = shape(input_dimension, units2),
initializer=initializers.random_normal(),
trainable=True)
self.pi_bias = self.add_weight(name="pi_bias",
shape = shape(units2),
initializer=initializers.zeros(),
trainable=True)
def __init__(self):
(self.train_X, self.train_y), (self.test_X,
self.test_y) = mnist.load_data()
self.image_input_layer = layers.InputLayer(input_shape=(28, 28, 1))
self.convolution2d_layer = layers.Conv2D(
20,
use_bias=True,
strides=(1, 1),
activation='relu',
padding='same',
kernel_size=(5, 5),
kernel_initializer=initializers.random_normal(mean=0,
stddev=0.01,
seed=None))
self.max_pooling2d_layer = layers.MaxPooling2D(strides=(2, 2),
pool_size=(2, 2),
padding='valid')
self.fully_connected_layer1 = layers.Dense(
100,
use_bias=True,
activation='relu',
kernel_initializer=initializers.random_normal(mean=0,
stddev=0.01,
seed=None))
self.fully_connected_layer2 = layers.Dense(10,
use_bias=True,
activation='softmax')
self.optimizer = SGD(momentum=0.9, lr=0.001)
self.history_list = list()
self.score_list = list()
def _kernel_init(kernel_size):
if 'tanh' == activations.serialize(self.activation):
stddev = np.sqrt(1. / (kernel_size * self.char_dim))
return initializers.random_normal(mean=0., stddev=stddev)
if 'relu' == activations.serialize(self.activation):
return 'random_uniform'
return 'glorot_uniform'
def _build_q_net(self):
model = keras.Sequential()
self.f1 = kl.Dense(
units=20,
input_shape=(self.n_features, ),
activation='relu',
kernel_initializer=initializers.random_normal(mean=0, stddev=0.1),
bias_initializer=initializers.constant_initializer(0.1))
self.all_act = kl.Dense(
units=self.n_actions,
activation=None,
kernel_initializer=initializers.random_normal(mean=0, stddev=0.1),
bias_initializer=initializers.constant_initializer(0.1))
self.all_act_prob = kl.Activation('softmax')
model.add(self.f1)
model.add(self.all_act)
model.add(self.all_act_prob)
def _sparse_softmax_cross_entropy_with_logits(self, target):
pass
def get_model(learning_rate, std_dev):
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(
1000,
activation=tf.nn.sigmoid,
kernel_initializer=random_normal(stddev=std_dev)),
tf.keras.layers.Dense(
100,
activation=tf.nn.sigmoid,
kernel_initializer=random_normal(stddev=std_dev)),
tf.keras.layers.Dense(
50,
activation=tf.nn.sigmoid,
kernel_initializer=random_normal(stddev=std_dev)),
tf.keras.layers.Dense(
100,
activation=tf.nn.sigmoid,
kernel_initializer=random_normal(stddev=std_dev)),
tf.keras.layers.Dense(
1000,
activation=tf.nn.sigmoid,
kernel_initializer=random_normal(stddev=std_dev)),
tf.keras.layers.Dense(
D * D * 3,
activation=tf.nn.sigmoid,
kernel_initializer=random_normal(stddev=std_dev)),
])
model.compile(optimizer=tf.train.AdamOptimizer(learning_rate),
loss='mean_squared_error',
metrics=['accuracy'])
return model
def build(self, input_shape=None):
channels = input_shape[-1]
if channels is None:
raise ValueError('Channel dimension of the inputs should be defined. Found `None`.')
self.input_spec = layers.InputSpec(ndim=max(2, len(input_shape)), axes={-1: channels})
kernel_initializer = initializers.random_normal(mean=0., stddev=np.sqrt(1. / channels))
self.carry = layers.Dense(
channels,
kernel_initializer=kernel_initializer,
bias_initializer=initializers.constant(-2.),
activation='sigmoid')
self.transform = layers.Dense(
channels,
kernel_initializer=kernel_initializer,
activation='relu')
super().build(input_shape)
def build(self, input_shape):
self.kernel_mu = self.add_weight(
name='kernel_mu',
shape=(input_shape[1], self.units),
initializer=tf.keras.initializers.random_normal(
stddev=self.init_sigma),
trainable=True)
self.bias_mu = self.add_weight(
name='bias_mu',
shape=(self.units, ),
initializer=initializers.random_normal(stddev=self.init_sigma),
trainable=True)
self.kernel_rho = self.add_weight(
name='kernel_rho',
shape=(input_shape[1], self.units),
initializer=initializers.constant(0.0),
trainable=True)
self.bias_rho = self.add_weight(name='bias_rho',
shape=(self.units, ),
initializer=initializers.constant(0.0),
trainable=True)
super().build(input_shape)
def __init__(self, weights_path, train_conv_layers):
self.__angle_values = [-1, -0.5, 0, 0.5, 1]
self.__nb_actions = 5
self.__gamma = 0.99
#Define the model
activation = 'relu'
pic_input = Input(shape=(59, 255, 3))
img_stack = Conv2D(16, (3, 3),
name='convolution0',
padding='same',
activation=activation,
trainable=train_conv_layers)(pic_input)
img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack)
img_stack = Conv2D(32, (3, 3),
activation=activation,
padding='same',
name='convolution1',
trainable=train_conv_layers)(img_stack)
img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack)
img_stack = Conv2D(32, (3, 3),
activation=activation,
padding='same',
name='convolution2',
trainable=train_conv_layers)(img_stack)
img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack)
img_stack = Flatten()(img_stack)
img_stack = Dropout(0.2)(img_stack)
img_stack = Dense(
128,
name='rl_dense',
kernel_initializer=random_normal(stddev=0.01))(img_stack)
img_stack = Dropout(0.2)(img_stack)
output = Dense(
self.__nb_actions,
name='rl_output',
kernel_initializer=random_normal(stddev=0.01))(img_stack)
opt = Adam()
self.__action_model = Model(inputs=[pic_input], outputs=output)
self.__action_model.compile(optimizer=opt, loss='mean_squared_error')
self.__action_model.summary()
self.__data_dir = ""
self.__experiment_name = "local_run"
# If we are using pretrained weights for the conv layers, load them and verify the first layer.
if (weights_path is not None and len(weights_path) > 0):
print('Loading weights from my_model_weights.h5...')
print('Current working dir is {0}'.format(os.getcwd()))
self.__action_model.load_weights(weights_path, by_name=True)
print('First layer: ')
w = np.array(self.__action_model.get_weights()[0])
print(w)
else:
print('Not loading weights')
# Set up the target model.
# This is a trick that will allow the model to converge more rapidly.
#commenting out next 4 lines
self.__action_context = tf.get_default_graph(
) #tf.compat.v1.get_default_graph() #tf.get_default_graph()
self.__target_model = clone_model(self.__action_model)
self.__target_context = tf.get_default_graph(
) #tf.compat.v1.get_default_graph() #tf.get_default_graph()
self.__model_lock = threading.Lock()