def _build_model(self): model = self.load() if model is None: main_input = Input(shape=self.input_dim, name='main_input') block = self._add_conv_block( prev_block=main_input, filters=self.layers_metadata[0]['filters'], kernel_size=self.layers_metadata[0]['kernel_size']) if len(self.layers_metadata) > 1: for metadata in self.layers_metadata[1:]: block = self._add_residual_block( prev_block=block, filters=metadata['filters'], kernel_size=metadata['kernel_size']) value_head = self._add_value_head(prev_block=block) policy_head = self._add_policy_head(prev_block=block) model = Model(inputs=main_input, outputs=[value_head, policy_head]) model.compile(loss={ 'value_head': 'mse', 'policy_head': 'categorical_crossentropy' }, optimizer=SGD(lr=self.learning_rate), loss_weights={ 'value_head': 0.5, 'policy_head': 0.5 }, metrics={ 'value_head': 'mse', 'policy_head': 'acc' }) # invoke following 3 protected methods to make the model can be shared by multiple threads model._make_predict_function() model._make_train_function() model._make_test_function() return model
def build_local_model(self): """ This method builds local networks (actor network and critic network) """ input = Input(shape=self.state_size) conv = Conv2D(16, (8, 8), strides=(4, 4), activation='relu')(input) conv = Conv2D(32, (4, 4), strides=(2, 2), activation='relu')(conv) conv = Flatten()(conv) fc = Dense(256, activation='relu')(conv) policy = Dense(self.action_size, activation='softmax')(fc) value = Dense(1, activation='linear')(fc) local_actor = Model(inputs=input, outputs=policy) local_critic = Model(inputs=input, outputs=value) local_actor._make_predict_function() local_critic._make_predict_function() local_actor.set_weights(self.actor.get_weights()) local_critic.set_weights(self.critic.get_weights()) local_actor.summary() local_critic.summary() return local_actor, local_critic
def build_model(self): state = Input(batch_shape=(None, self.state_size)) actor_input = Dense(30, input_dim=self.state_size, activation='relu', kernel_initializer='he_uniform')(state) # actor_hidden = Dense(self.hidden2, activation='relu')(actor_input) #tanh output of [-1,1] mu_0 = Dense(self.action_size, activation='tanh', kernel_initializer='he_uniform')(actor_input) #softplus gives output [0, inf] and deriv is sigmoid sigma_0 = Dense(self.action_size, activation='softplus', kernel_initializer='he_uniform')(actor_input) #mu is doubled to fit the action space of [-2, 2]? mu = Lambda(lambda x: x * 2)(mu_0) #custom layer ensures that sigma is not 0 sigma = Lambda(lambda x: x + 0.0001)(sigma_0) #critic also takes in state and outputs a value critic_input = Dense(30, input_dim=self.state_size, activation='relu', kernel_initializer='he_uniform')(state) # value_hidden = Dense(self.hidden2, activation='relu')(critic_input) state_value = Dense(1, activation='linear', kernel_initializer='he_uniform')(critic_input) actor = Model(inputs=state, outputs=(mu, sigma)) critic = Model(inputs=state, outputs=state_value) #must declare before use actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
def build_model(self, actor_only=False): state = Input(shape=self.state_size) state_process = BatchNormalization()(state) state_process = Dense(100, activation='elu')(state) state_process = BatchNormalization()(state_process) state_process = Dense(100, activation='elu')(state_process) state_process = BatchNormalization()(state_process) policy = Dense(self.action_size, activation='tanh', kernel_initializer=tf.random_uniform_initializer( minval=-3e-3, maxval=3e-3))(state_process) value = Dense(1, activation='linear', kernel_initializer=tf.random_uniform_initializer( minval=-3e-3, maxval=3e-3))(state_process) actor = Model(inputs=state, outputs=policy, name='Actor') actor._make_predict_function() if actor_only: return actor critic = Model(inputs=state, outputs=value, name='Critic') critic._make_predict_function() return actor, critic
def _initModel(self, hyperparameters, shape): print(shape) base_model = InceptionV3(weights=None, include_top=False, input_shape=shape) # add a global spatial average pooling layer x = base_model.output x = GlobalAveragePooling2D()(x) # add a fully-connected layer x = Dense(hyperparameters["fc_size"], activation=hyperparameters["fc_activation"])(x) # add a logistic layer predictions = Dense(1, kernel_initializer='normal')(x) # train this model model = Model(inputs=base_model.input, outputs=predictions) for layer in base_model.layers: layer.trainable = False # compile the model (should be done *after* setting layers to non-trainable) model.compile(optimizer='adam', loss=hyperparameters["loss"], metrics=hyperparameters["metrics"]) # fix model loading bug # https://github.com/keras-team/keras/issues/2397 model._make_predict_function() print(model.summary()) return model
def _build_model(self): with tf.variable_scope(self.name): input_layer = Input(shape=self.input_shape) cnn_input_layer = Conv2D(input_shape=self.input_shape, filters=self.filter_count, kernel_size=self.filter_size, padding='same', activation='relu', name='cnn_input')(input_layer) prev_layer = cnn_input_layer # TODO: adjust cnn layer count. cnn_layer_count = 0 for i in range(cnn_layer_count): hidden_layer = Conv2D(filters=self.filter_count, kernel_size=self.filter_size, padding='same', activation='relu', name='conv{}'.format(i))(prev_layer) prev_layer = hidden_layer flatten_layer = Flatten()(prev_layer) output_policy_layer = Dense(units=self.action_count, activation='softmax')(flatten_layer) output_value_layer = Dense(1, activation='linear')(flatten_layer) model = Model(input=[input_layer], outputs=[output_policy_layer, output_value_layer]) # Since this model will be not evaluated in a3c algorithm, expressly do it to be available vars. model._make_predict_function() self.model = model
def build_model(self): state_size = list(self.state_size) state_size.append(1) state = Input(shape=self.state_size) reshape = Reshape(state_size)(state) conv = TimeDistributed(Conv2D(16, (8, 8), strides=(4, 4), activation='relu'))(reshape) conv = TimeDistributed(Conv2D(32, (4, 4), strides=(2, 2), activation='relu'))(conv) conv = TimeDistributed(Flatten())(conv) lstm_state = LSTM(512, activation='relu')(conv) action_output = Dense(self.action_size, activation='tanh')(lstm_state) actor_output = Lambda(lambda x: x * np.pi)(action_output) actor = Model(inputs=state, outputs=action_output) action = Input([self.action_size]) state_action = Concatenate()([lstm_state, action]) fc = Dense(512, activation='relu')(state_action) Q_output = Dense(1)(fc) critic = Model(inputs=[state, action], outputs=Q_output) actor._make_predict_function() critic._make_predict_function() if VERBOSE: actor.summary() critic.summary() return actor, critic
def build_model(self): state = Input(batch_shape=(None, self.state_size)) actor_input = Dense(self.hidden1, input_dim=self.state_size, activation='relu')(state) actor_hidden = Dense(self.hidden2, activation='relu')(actor_input) mu_0 = Dense(self.action_size, activation='tanh')(actor_hidden) sigma_0 = Dense(self.action_size, activation='softplus')(actor_hidden) mu = Lambda(lambda x: x * 2)(mu_0) sigma = Lambda(lambda x: x + 0.0001)(sigma_0) critic_input = Dense(self.hidden1, input_dim=self.state_size, activation='relu')(state) value_hidden = Dense(self.hidden2, activation='relu', kernel_initializer='he_uniform')(critic_input) state_value = Dense(1, activation='linear', kernel_initializer='he_uniform')(value_hidden) actor = Model(inputs=state, outputs=(mu, sigma)) critic = Model(inputs=state, outputs=state_value) actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
def build_model(self): state = Input(batch_shape=(None, 2, int(self.state_size / 2))) lstm_layer = LSTM(self.hidden0, activation='tanh', kernel_initializer='glorot_uniform')(state) shared = Dense(self.hidden1, activation='relu', kernel_initializer='glorot_uniform')(lstm_layer) actor_hidden = Dense(self.hidden2, activation='relu', kernel_initializer='glorot_uniform')(shared) action_prob = Dense(self.action_size, activation='softmax', kernel_initializer='glorot_uniform')(actor_hidden) value_hidden = Dense(self.hidden2, activation='relu', kernel_initializer='he_uniform')(shared) state_value = Dense(1, activation='linear', kernel_initializer='he_uniform')(value_hidden) actor = Model(inputs=state, outputs=action_prob) critic = Model(inputs=state, outputs=state_value) actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
def build_actor(self): #base for two heads of mean and variance base = Input(batch_shape=(None, self.state_size), name='states') net = Dense(units=self.hidden_size, use_bias=False, activation='relu')(base) #mu head mu = Dense(units=1, activation='tanh')(net) #custom layer for Pendulum mu = Lambda(lambda x: x * 2)(mu) #sigma head sigma_sq = Dense(units=1, activation='softplus')(net) #custom layer to ensure non-zero variance sigma_sq = Lambda(lambda x: x + 0.0001)(sigma_sq) actor = Model(inputs=base, outputs=(mu, sigma_sq)) #prep the function actor._make_predict_function() actor.summary() return actor
def build_local_model(self): input = Input(shape=self.state_size) conv = Conv2D(32, (8, 8), strides=(4, 4), activation='relu')(input) conv = Conv2D(64, (4, 4), strides=(2, 2), activation='relu')(conv) # Simplifying network from original DQN conv = Conv2D(64, (3, 3), strides=(1, 1), activation='relu')(conv) conv = Flatten()(conv) # Simplifying network from original DQN fc = Dense(512, activation='relu')(conv) #fc = Dense(256)(conv) policy = Dense(self.action_size, activation='softmax')(fc) value = Dense(1, activation='linear')(fc) local_actor = Model(inputs=input, outputs=policy) local_critic = Model(inputs=input, outputs=value) local_actor._make_predict_function() local_critic._make_predict_function() # Synchronizing with global network local_actor.set_weights(self.actor.get_weights()) local_critic.set_weights(self.critic.get_weights()) local_actor.summary() local_critic.summary() return local_actor, local_critic
def build_model(self): input = Input(shape=self.state_size) # conv = TimeDistributed(Conv2D(64, (8, 8), strides=(4, 4), padding='same', activation='elu', kernel_initializer='he_normal'))(input) # conv = TimeDistributed(Conv2D(32, (4, 4), strides=(2, 2), activation='elu', kernel_initializer='he_normal'))(conv) # conv = TimeDistributed(Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal'))(conv) # conv = TimeDistributed(Conv2D(16, (1, 1), activation='elu', kernel_initializer='he_normal'))(conv) conv = TimeDistributed(Flatten())(input) batch_norm = BatchNormalization()(conv) gru = GRU(256, activation='tanh', kernel_initializer='he_normal')(batch_norm) policy = Dense(self.action_size, activation='softmax', kernel_initializer='he_normal')(gru) value = Dense(1, activation='linear', kernel_initializer='he_normal')(gru) actor = Model(inputs=input, outputs=policy) critic = Model(inputs=input, outputs=value) actor._make_predict_function() critic._make_predict_function() if self.verbose: actor.summary() critic.summary() return actor, critic
def build_local_model(self, state_size, action_size): input = Input(shape=(1, state_size)) d = LSTM(48, kernel_initializer='he_uniform')(input) # input = Input(shape=(state_size,)) # d = Dense(48, activation='relu', # kernel_initializer='he_uniform')(input) # d = Dense(48, activation='relu', # kernel_initializer='he_uniform')(d) # d = Dense(24, activation='relu', # kernel_initializer='he_uniform')(d) policy = Dense(action_size, activation='softmax')(d) value = Dense(1, activation='linear')(d) local_actor = Model(inputs=input, outputs=policy) local_critic = Model(inputs=input, outputs=value) local_actor._make_predict_function() local_critic._make_predict_function() local_actor.set_weights(self.actor.get_weights()) local_critic.set_weights(self.critic.get_weights()) local_actor.summary() local_critic.summary() return local_actor, local_critic
def build_local_model(self): input = Input(shape=(self.state_size, )) dropout = 0.2 fc = Dense(64, activation='relu', kernel_initializer='lecun_uniform')(input) fc = Dense(64, activation='relu', kernel_initializer='lecun_uniform')(fc) fc = Dropout(dropout)(fc) policy = Dense(self.action_size, activation='softmax')(fc) value = Dense(1, activation='linear')(fc) local_actor = Model(inputs=input, outputs=policy) local_critic = Model(inputs=input, outputs=value) local_actor._make_predict_function() local_critic._make_predict_function() local_actor.set_weights(self.actor.get_weights()) local_critic.set_weights(self.critic.get_weights()) local_actor.summary() local_critic.summary() return local_actor, local_critic
def build_model(self): input = Input(self.state_size) ############# CNN ################# conv = Conv2D(16, (4, 4), strides=(2, 2), activation='relu')(input) # output = 7x14x16 conv = Conv2D(32, (3, 3), strides=(1, 1), activation='relu')(conv) # output = 5x10x32 conv = Flatten()(conv) # output = 1600 fc = Dense(256, activation='relu')(conv) ##################################### policy = Dense(self.action_size, activation='softmax')(fc) value = Dense(1, activation='linear')(fc) # actor: 상태를 받아 각 행동의 확률을 계산 actor = Model(inputs=input, outputs=policy) # critic: 상태를 받아서 상태의 가치를 계산 critic = Model(inputs=input, outputs=value) # 멀티스레딩을 케라스에서 이용할 때 발셍하는 에러 제거 actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
def build_local_model(self): input = Input(shape=self.state_size) ############# CNN ################# conv = Conv2D(16, (4, 4), strides=(2, 2), activation='relu')(input) # output = 7x14x16 conv = Conv2D(32, (3, 3), strides=(1, 1), activation='relu')(conv) # output = 5x10x32 conv = Flatten()(conv) # output = 1600 fc = Dense(256, activation='relu')(conv) ##################################### policy = Dense(self.action_size, activation='softmax')(fc) value = Dense(1, activation='linear')(fc) # actor: 상태를 받아 각 행동의 확률을 계산 # critic: 상태를 받아서 상태의 가치를 계산 local_actor = Model(inputs=input, outputs=policy) local_critic = Model(inputs=input, outputs=value) local_actor._make_predict_function() local_critic._make_predict_function() local_actor.set_weights(self.actor.get_weights()) local_critic.set_weights(self.critic.get_weights()) local_actor.summary() local_critic.summary() return local_actor, local_critic
def build_model(self): state = Input(batch_shape=(None, self.state_size)) shared = Dense(self.hidden1, input_dim=self.state_size, activation='relu', kernel_initializer='he_uniform')(state) actor_hidden1 = Dense(self.hidden2, activation='relu', kernel_initializer='he_uniform')(shared) action_prob = Dense(self.action_size, activation='softmax', kernel_initializer='he_uniform')(actor_hidden1) value_hidden1 = Dense(self.hidden2, activation='relu', kernel_initializer='he_uniform')(shared) state_value = Dense(1, activation='linear', kernel_initializer='he_uniform')(value_hidden1) actor = Model(inputs=state, outputs=action_prob) critic = Model(inputs=state, outputs=state_value) actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
def create_model(self): input_layer = Input(shape=(None, self.action_space_size)) lstm_layer_1 = LSTM(10, return_sequences=True)(input_layer) lstm_layer_2 = LSTM(10, return_sequences=True)(lstm_layer_1) sub_last_layer = Dense(10)(lstm_layer_2) ### splitting last layer output_angles = Dense(self.angle_vect_size)(sub_last_layer) #analog output output_pressure = Dense( self.pressure_vect_size, activation='sigmoid')(sub_last_layer) #binary output output_reward = Dense(self.reward_vect_size)( sub_last_layer) #analog output model = Model( inputs=input_layer, outputs=[output_angles, output_pressure, output_reward]) model.compile( optimizer=SGD(lr=0.00001), loss=['mse', 'binary_crossentropy', 'mse'], metrics=['accuracy'], loss_weights=[0.10, 0.06, 0.04]) model._make_predict_function() return model
def _build_model(self): if self.conv: main_input, x = self.get_conv_layers() out_value = self.conv_layer(x, 1, (1, 1)) out_value = Flatten()(out_value) out_value = self.dense_layer(out_value, 1) out_actions = self.policy_head(x) else: main_input = Input(batch_shape=(None, self.stateCnt)) x = main_input if len(self.layers) > 0: for h in self.layers: x = self.dense_layer(x, h['size'], reg=None) x = LeakyReLU()(x) out_value = self.dense_layer(x, 1, reg=None) out_actions = self.dense_layer(x, self.actionCnt, 'softmax', 'policy_head', reg=None) model = Model(inputs=[main_input], outputs=[out_actions, out_value]) model._make_predict_function() # have to initialize before threading return model
def build_model(self): state = Input([self.state_size]) fc1 = Dense(100, activation='elu')(state) # fc1 = BatchNormalization()(fc1) # fc1 = Dense(100, activation='elu')(fc1) action_output = Dense(self.action_size, activation='tanh')(fc1) actor = Model(inputs=state, outputs=action_output) # state = Input([self.state_size], batch_shape=[self.batch_size, self.state_size]) action = Input([self.action_size]) action_process = Dense(100, activation='elu')(action) # action_process = BatchNormalization()(action_process) # state_process = Dense(100, activation='elu')(state) # state_process = BatchNormalization()(state_process) # state_process = Dense(100, activation='elu')(state_process) state_action = Add()([fc1, action_process]) fc2 = Dense(50, activation='elu')(state_action) Q_output = Dense(1)(fc2) critic = Model(inputs=[state, action], outputs=Q_output) # action_grad = tf.gradients(critic.output, action) actor._make_predict_function() critic._make_predict_function() if VERBOSE: actor.summary() critic.summary() return actor, critic
def load_model(input_shape): global model # load the pre-trained keras model base_network = create_base_network_signet(input_shape) base_network.summary() input_a = Input(shape=(input_shape)) input_b = Input(shape=(input_shape)) # because we re-use the same instance `base_network`, # the weights of the network will be shared across the two branches processed_a = base_network(input_a) processed_b = base_network(input_b) distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)( [processed_a, processed_b]) model_path = 'model_v4.hdf5' exists = os.path.isfile(model_path) if not exists: print('Beginning file download with wget module...') url = "https://docs.google.com/uc?export=download&id=1Z_dmvFepAjJvlJ-ut0OywnOsFw4n4Onh" wget.download(url) model = Model(inputs=[input_a, input_b], outputs=distance) model.load_weights(model_path) model._make_predict_function()
def build_model(self): state = Input([self.state_size], batch_shape=[self.batch_size, self.state_size]) fc1 = Dense(256, activation='relu', kernel_initializer='he_normal')(state) action_output = Dense(self.action_size, activation='linear', kernel_initializer='he_normal')(fc1) actor = Model(inputs=state, outputs=action_output) # state = Input([self.state_size], batch_shape=[self.batch_size, self.state_size]) action = Input([self.action_size], batch_shape=[self.batch_size, self.action_size]) state_action = Concatenate()([state, action]) fc2 = Dense(256, activation='relu', kernel_initializer='he_normal')(state_action) Q_output = Dense(1, activation='linear', kernel_initializer='he_normal')(fc2) critic = Model(inputs=[state, action], outputs=Q_output) # action_grad = tf.gradients(critic.output, action) actor._make_predict_function() critic._make_predict_function() if VERBOSE: actor.summary() critic.summary() return actor, critic
def loadNet(NET): # Utilizar la memoria necesaria config = tf.ConfigProto() config.gpu_options.allow_growth = True set_session(tf.Session(config=config)) if (NET == "RES"): net = keras.applications.resnet50.ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) inP = net.input ouT = net.get_layer('flatten_1').output net = Model(inputs=inP, outputs=ouT) if (NET == "RESV2"): net = keras.applications.inception_resnet_v2.InceptionResNetV2( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) inP = net.input ouT = net.get_layer('avg_pool').output net = Model(inputs=inP, outputs=ouT) net._make_predict_function() return net
def build_model(self): input = Input(shape=self.state_size) conv = Conv2D(32, (8, 8), strides=(4, 4), activation='relu')(input) conv = Conv2D(64, (4, 4), strides=(2, 2), activation='relu')(conv) # Simplifying network from original DQN conv = Conv2D(64, (3, 3), strides=(1, 1), activation='relu')(conv) conv = Flatten()(conv) # Simplifying network from original DQN fc = Dense(512, activation='relu')(conv) #fc = Dense(256)(conv) # Using softmax function to make probability policy = Dense(self.action_size, activation='softmax')(fc) value = Dense(1, activation='linear')(fc) actor = Model(inputs=input, outputs=policy) critic = Model(inputs=input, outputs=value) # Making predicting function # According to textbook, this is not for training itself # For preventing error in multi-threading actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
def __build_actor_critic__(self): input_ = Input(shape=self.input_shape_) conv = Conv2D(filters=32,kernel_size=(8,8),padding="valid",strides=(2,2))(input_) conv = BatchNormalization()(conv) conv = Activation('relu')(conv) conv = Conv2D(filters=32,kernel_size=(8,8),padding="valid",strides=(2,2))(conv) conv = BatchNormalization()(conv) conv = Activation('relu')(conv) conv = Conv2D(filters=32,kernel_size=(8,8),padding="valid",strides=(2,2))(conv) conv = BatchNormalization()(conv) conv = Activation('relu')(conv) flat = Flatten()(conv) dense = Dense(units=512)(flat) dense = Activation('relu')(dense) dense = Dense(units=128)(dense) dense = Activation('relu')(dense) policy = Dense(units=self.output_shape_, activation='softmax')(dense) value = Dense(units=1,activation='linear')(dense) actor = Model(inputs=input_,outputs=policy) critic = Model(inputs=input_,outputs=value) actor._make_predict_function() critic._make_predict_function() return actor,critic
class PredictionModel: def __init__(self): _NUM_CLASSES = 4 input_shape = (128, 128, 1,) input_layer = Input(shape=input_shape) bn_axis = 2 # Block 1 x = BatchNormalization(axis=bn_axis)(input_layer) x = Conv2D(64, (3, 3), strides=(1, 1), activation='relu', padding='same', name='conv1')(x) x = MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='pool1')(x) # Block 2 x = BatchNormalization(axis=bn_axis)(x) x = Conv2D(128, (3, 3), strides=(1, 1), activation='relu', padding='same', name='conv2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='pool2')(x) # Block 3 x = BatchNormalization(axis=bn_axis)(x) x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', padding='same', name='conv3/conv3_1')(x) x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', padding='same', name='conv3/conv3_2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='pool3')(x) # Block 4 x = BatchNormalization(axis=bn_axis)(x) x = Conv2D(512, (3, 3), strides=(1, 1), activation='relu', padding='same', name='conv4/conv4_1')(x) x = Conv2D(512, (3, 3), strides=(1, 1), activation='relu', padding='same', name='conv4/conv4_2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), padding='same', name='pool4')(x) # x = GlobalAveragePooling2D()(x) x = Reshape((8, -1))(x) # # Previously LSTM layer was 64 nodes x = LSTM(128, return_sequences=True, kernel_regularizer=regularizers.l2(0.01), stateful=False)(x) x = LSTM(128, return_sequences=True, kernel_regularizer=regularizers.l2(0.01), stateful=False)(x) x = Dropout(0.5)(x) # x = Dense(64, activation='relu')(x) x = Dense(_NUM_CLASSES, activation='softmax')(x) self.model = Model(inputs=input_layer, outputs=x) self.model.load_weights(weights_path) self.model._make_predict_function() self.threshold = 0.0 def predict(self, x): x = np.expand_dims(x, axis=-1) predictions = self.model.predict(x) labels = np.full((predictions.shape[0], predictions.shape[1]), 3) # labels = np.array([3]*predictions.shape[1], dtype=np.int64) for j in range(predictions.shape[0]): for i in range(predictions.shape[1]): label = np.argmax(predictions[j, i]) labels[j, i] = label if predictions[j, i, label] > self.threshold else 3 return labels def predict_one_label(self, x): labels = self.predict(x) print(labels) labels = np.squeeze(labels, axis=0) return class_mapping[np.argmax(np.bincount(labels))]
def build_model(self, net_type='DNN', in_pa=1, ou_pa=1, time_leg=1): from keras.layers import Dense, Input, Conv1D, MaxPooling1D, LSTM, Flatten from keras.models import Model # 8 16 32 64 128 256 512 1024 2048 if net_type == 'DNN': state = Input(batch_shape=(None, in_pa)) shared = Dense(32, input_dim=in_pa, activation='relu', kernel_initializer='glorot_uniform')(state) # shared = Dense(48, activation='relu', kernel_initializer='glorot_uniform')(shared) elif net_type == 'CNN' or net_type == 'LSTM' or net_type == 'CLSTM': state = Input(batch_shape=(None, time_leg, in_pa)) if net_type == 'CNN': shared = Conv1D(filters=10, kernel_size=3, strides=1, padding='same')(state) shared = MaxPooling1D(pool_size=2)(shared) shared = Flatten()(shared) elif net_type == 'LSTM': shared = LSTM(32, activation='relu')(state) shared = Dense(64)(shared) elif net_type == 'CLSTM': shared = Conv1D(filters=10, kernel_size=3, strides=1, padding='same')(state) shared = MaxPooling1D(pool_size=2)(shared) shared = LSTM(8)(shared) # ---------------------------------------------------------------------------------------------------- # Common output network actor_hidden = Dense(64, activation='relu', kernel_initializer='glorot_uniform')(shared) action_prob = Dense(ou_pa, activation='softmax', kernel_initializer='glorot_uniform')(actor_hidden) value_hidden = Dense(32, activation='relu', kernel_initializer='he_uniform')(shared) state_value = Dense(1, activation='linear', kernel_initializer='he_uniform')(value_hidden) actor = Model(inputs=state, outputs=action_prob) critic = Model(inputs=state, outputs=state_value) actor._make_predict_function() critic._make_predict_function() return actor, critic
def load_detect_model(model_path): print('loading saved ocr detection model from - {}'.format(model_path)) input_image = Input(shape=(None, None, 3), name='image', dtype=tf.float32) region, affinity = VGG16_UNet(input_tensor=input_image, weights=None) model = Model(inputs=[input_image], outputs=[region, affinity]) model.load_weights(model_path) model._make_predict_function() return model
def build_network(state_dim): state_input = Input((state_dim, )) h1 = Dense(64, activation='relu')(state_input) h2 = Dense(32, activation='relu')(h1) h3 = Dense(16, activation='relu')(h2) v_output = Dense(1, activation='linear')(h3) model = Model(state_input, v_output) model._make_predict_function() return model, model.trainable_weights, state_input
def build_model(self, net_type='DNN', in_pa=1, ou_pa=1, time_leg=1): # 8 16 32 64 128 256 512 1024 2048 if net_type == 'DNN': state = Input(batch_shape=(None, in_pa)) shared = Dense(32, input_dim=in_pa, activation='relu', kernel_initializer='glorot_uniform')(state) shared = Dense(64, activation='relu', kernel_initializer='glorot_uniform')(shared) shared = Dense(70, activation='relu', kernel_initializer='glorot_uniform')(shared) elif net_type == 'CNN' or net_type == 'LSTM' or net_type == 'CLSTM': state = Input(batch_shape=(None, time_leg, in_pa)) if net_type == 'CNN': shared = Conv1D(filters=10, kernel_size=3, strides=1, padding='same')(state) shared = MaxPooling1D(pool_size=3)(shared) shared = Flatten()(shared) shared = Dense(64)(shared) shared = Dense(70)(shared) elif net_type == 'LSTM': shared = LSTM(32)(state) shared = Dense(64)(shared) elif net_type == 'CLSTM': shared = Conv1D(filters=10, kernel_size=5, strides=1, padding='same')(state) shared = MaxPooling1D(pool_size=3)(shared) shared = LSTM(12)(shared) shared = Dense(24)(shared) # ---------------------------------------------------------------------------------------------------- # Common output network # actor_hidden = Dense(64, activation='relu', kernel_initializer='glorot_uniform')(shared) if MULTTACT: actor_hidden = Dense(24, activation='relu', kernel_initializer='glorot_uniform')(shared) action_prob = Dense(ou_pa, activation='tanh', kernel_initializer='glorot_uniform')(actor_hidden) else: actor_hidden = Dense(24, activation='sigmoid', kernel_initializer='glorot_uniform')(shared) action_prob = Dense(ou_pa, activation='softmax', kernel_initializer='glorot_uniform')(actor_hidden) # value_hidden = Dense(32, activation='relu', kernel_initializer='he_uniform')(shared) value_hidden = Dense(12, activation='sigmoid', kernel_initializer='he_uniform')(shared) state_value = Dense(1, activation='linear', kernel_initializer='he_uniform')(value_hidden) actor = Model(inputs=state, outputs=action_prob) critic = Model(inputs=state, outputs=state_value) fully_model = Model(inputs=state, outputs=[action_prob, state_value]) print('Make {} Network'.format(net_type)) actor._make_predict_function() critic._make_predict_function() actor.summary(print_fn=logging.info) critic.summary(print_fn=logging.info) return actor, critic, fully_model
def build_model(self): input = Input(shape=self.state_size) conv = Conv2D(16, (8, 8), strides=(4, 4), activation='relu')(input) conv = Conv2D(32, (4, 4), strides=(2, 2), activation='relu')(conv) conv = Flatten()(conv) fc = Dense(256, activation='relu')(conv) policy = Dense(self.action_size, activation='softmax')(fc) value = Dense(1, activation='linear')(fc) actor = Model(inputs=input, outputs=policy) critic = Model(inputs=input, outputs=value) actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
def build_model(self): state = Input(batch_shape=(None, self.state_size)) shared = Dense(self.hidden1, input_dim=self.state_size, activation='relu', kernel_initializer='glorot_uniform')(state) actor_hidden = Dense(self.hidden2, activation='relu', kernel_initializer='glorot_uniform')(shared) action_prob = Dense(self.action_size, activation='softmax', kernel_initializer='glorot_uniform')(actor_hidden) value_hidden = Dense(self.hidden2, activation='relu', kernel_initializer='he_uniform')(shared) state_value = Dense(1, activation='linear', kernel_initializer='he_uniform')(value_hidden) actor = Model(inputs=state, outputs=action_prob) critic = Model(inputs=state, outputs=state_value) actor._make_predict_function() critic._make_predict_function() actor.summary() critic.summary() return actor, critic
dis_op = Adam(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=1e-08) cls_op = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) gen_op = Adam(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=1e-08) #gen_op = RMSprop(lr=0.001, rho=0.9, epsilon=1e-06) ## MODEL (gen, (dis, cls)) = get_models(dataset,smallmodel) dis.trainable = False x = Input(shape=(gen_dim,)) h = gen(x) y = dis(h) disgen = Model(input=x, output=y) disgen.compile(loss='binary_crossentropy', optimizer=gen_op, metrics=['accuracy']) disgen._make_train_function() disgen._make_test_function() disgen._make_predict_function() #noise_batch = np.random.uniform(-1, 1, (batch_size, gen_dim)).astype('float32') #labels2 = np.ones((batch_size, 1)).astype('float32') #g_loss = disgen.train_on_batch(noise_batch, labels2) dis.trainable = True dis.compile(loss='binary_crossentropy', optimizer=dis_op, metrics=['accuracy']) if classify: cls.trainable = True cls.compile(loss='categorical_crossentropy', optimizer=cls_op, metrics=['accuracy']) gen.compile(loss='mean_squared_error', optimizer=gen_op)