def test_fixed_loss_scaling(self, strategy_fn, experimental_run_tf_function=True): # Note: We do not test mixed precision in this method, only loss scaling. if not self._is_strategy_supported(strategy_fn): return loss_scale = 8. batch_size = 4 with strategy_fn().scope(): x = layers.Input(shape=(1, ), batch_size=batch_size) layer = AddLayer() y = layer(x) # The gradient of 'y' at this point is 1. With loss scaling, the gradient # is 'loss_scale'. We divide by the batch size since the loss is averaged # across batch elements. expected_gradient = loss_scale / batch_size identity_with_grad_check_fn = ( mp_test_util.create_identity_with_grad_check_fn( [expected_gradient])) y = core.Lambda(identity_with_grad_check_fn)(y) model = models.Model(inputs=x, outputs=y) def loss_fn(y_true, y_pred): del y_true return math_ops.reduce_mean(y_pred) opt = gradient_descent.SGD(1.) opt = loss_scale_optimizer.LossScaleOptimizer(opt, loss_scale) model.compile(opt, loss=loss_fn, run_eagerly=testing_utils.should_run_eagerly(), experimental_run_tf_function=testing_utils. should_run_tf_function()) self.assertEqual(backend.eval(layer.v), 1) x = np.ones((batch_size, 1)) y = np.ones((batch_size, 1)) dataset = dataset_ops.Dataset.from_tensor_slices( (x, y)).batch(batch_size) model.fit(dataset) # Variable starts at 1, and should have gradient of 1 subtracted from it. expected = 0 self.assertEqual(backend.eval(layer.v), expected)
def ternaus_model_building(img_shape): """Ternaus model declaration""" inputs = layers.Input(shape=img_shape) model = VGG16(weights="imagenet", include_top=False, input_tensor=inputs) layer_dict = dict([(layer.name, layer) for layer in model.layers]) for key in layer_dict: print(key) print(layer_dict[key]) print(layer_dict[key].output_shape) layer_dict[key].trainble = False def decoder_block(input_tensor, concat_tensor, num_filters_a, num_filters_b, up_scale=2): decoder = layers.Conv2DTranspose(num_filters_a, (3, 3), strides=(up_scale, up_scale), padding='same')(input_tensor) decoder = layers.BatchNormalization()(decoder) decoder = layers.Activation("relu")(decoder) decoder = layers.concatenate([concat_tensor, decoder], axis=-1) decoder = layers.BatchNormalization()(decoder) decoder = layers.Conv2D(num_filters_b, (3, 3), padding='same')(decoder) decoder = layers.BatchNormalization()(decoder) decoder = layers.Activation("relu")(decoder) return decoder actual_inputs = layers.Conv2D(512, (3, 3), padding='same')( layer_dict['block5_pool'].output) actual_inputs = layers.BatchNormalization()(actual_inputs) actual_inputs = decoder_block(actual_inputs, layer_dict['block5_conv3'].output, 256, 512) actual_inputs = decoder_block(actual_inputs, layer_dict['block4_conv3'].output, 256, 512) actual_inputs = decoder_block(actual_inputs, layer_dict['block3_conv3'].output, 128, 256) actual_inputs = decoder_block(actual_inputs, layer_dict['block2_conv2'].output, 64, 128) final = decoder_block(actual_inputs, layer_dict['block1_conv2'].output, 32, 1) model = models.Model(inputs=[inputs], outputs=[final]) return model
def network_1b(): """ 将原文网络最后的FC层改为512个神经元 acc=0, size=, time=0 :return: model """ inputs = kl.Input(shape=(8, 16, 1)) bone = kl.BatchNormalization(1)(inputs) # modified: 加入BN层,极大加快收敛速度并提高准确率 bone = kl.Conv2D(filters=32, kernel_size=(2, 1), padding='same', activation='relu', strides=(1, 1))(bone) bone = kl.MaxPool2D(pool_size=(2, 1), strides=(2, 1), padding='same')(bone) bone = kl.Conv2D(filters=16, kernel_size=(2, 1), padding='same', activation='relu', strides=(1, 1))(bone) bone = kl.MaxPool2D(pool_size=(2, 1), strides=(2, 1), padding='same')(bone) bone = kl.Conv2D(filters=16, kernel_size=(2, 1), padding='same', activation='relu', strides=(1, 1))(bone) bone = kl.Conv2D(filters=16, kernel_size=(2, 1), padding='same', activation='relu', strides=(1, 1))(bone) bone = kl.Conv2D(filters=16, kernel_size=(2, 1), padding='same', activation='relu', strides=(1, 1))(bone) bone = kl.Flatten()(bone) bone = kl.Dense(units=512, activation='relu')(bone) outputs = kl.Dense(units=6, activation='softmax')(bone) model = km.Model(inputs=inputs, outputs=outputs) model.summary() model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
def trivial(num_classes, batch_size=None, use_l2_regularizer=True): input_shape = (224, 224, 3) img_input = layers.Input(shape=input_shape, batch_size=batch_size) x = img_input if backend.image_data_format() == 'channels_first': x = layers.Lambda( lambda x: backend.permute_dimensions(x, (0, 3, 1, 2)), name='transpose')(x) bn_axis = 1 else: # channels_last bn_axis = 3 x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(x) x = layers.Conv2D( 64, (7, 7), strides=(2, 2), padding='valid', use_bias=False, kernel_initializer='he_normal', kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer), name='conv1')(x) x = layers.BatchNormalization(axis=bn_axis, momentum=BATCH_NORM_DECAY, epsilon=BATCH_NORM_EPSILON, name='bn_conv1')(x) rm_axes = [1, 2 ] if backend.image_data_format() == 'channels_last' else [2, 3] x = layers.Lambda(lambda x: backend.mean(x, rm_axes), name='reduce_mean')(x) x = layers.Dense( num_classes, kernel_initializer=initializers.RandomNormal(stddev=0.01), kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer), bias_regularizer=_gen_l2_regularizer(use_l2_regularizer), name='fc1000')(x) # A softmax that is followed by the model loss must be done cannot be done # in float16 due to numeric issues. So we pass dtype=float32. x = layers.Activation('softmax', dtype='float32')(x) # Create model. return models.Model(img_input, x, name='resnet50')
def get_model(style_layers, content_layers): # Load the model without the fully connected layers and pretrained on the imagenet dataset vgg19 = tf.keras.applications.vgg19.VGG19(include_top=False, weights=WEIGHTS) # Set trainable to false as we don't need to train the network vgg19.trainable = False # Get output layers corresponding to style and content Layers style_outputs = [vgg19.get_layer(layer).output for layer in style_layers] content_outputs = [ vgg19.get_layer(layer).output for layer in content_layers ] # Combining the output layers of Interest model_outputs = style_outputs + content_outputs # Build and return the model return models.Model(vgg19.input, model_outputs)
def build_model(): input1 = layers.Input(shape=(X_unstructure.shape[1], )) input2 = layers.Input(shape=(X_structure.shape[1], )) input1_bn = layers.BatchNormalization()(input1) x1_1 = layers.Dense(600, activation='tanh')(input1_bn) input2_bn = layers.BatchNormalization()(input2) x2_1 = layers.Dense(200, activation='tanh')(input2_bn) x_connect = tf.concat([x1_1, x2_1], 1) x_connect_1 = layers.Dense(600, activation='tanh')(x_connect) x_connect_2 = layers.Dense(400, activation='tanh')(x_connect_1) x_connect_2_d = layers.Dropout(0.3)(x_connect_2) y_connect_ = layers.Dense(2, activation='softmax')(x_connect_2_d) x1_2 = layers.Dense(600, activation='tanh', kernel_regularizer=regularizers.l2())(x1_1) x2_2 = layers.Dense(400, activation='tanh', kernel_regularizer=regularizers.l2())(x2_1) x1_2_d = layers.Dropout(0.3)(x1_2) x2_2_d = layers.Dropout(0.3)(x2_2) x1_3 = layers.Dense(600, activation='tanh', kernel_regularizer=regularizers.l2())(x1_2) x2_3 = layers.Dense(400, activation='tanh', kernel_regularizer=regularizers.l2())(x2_2) x1_3_d = layers.Dropout(0.3)(x1_3) x2_3_d = layers.Dropout(0.3)(x2_3) y1_ = layers.Dense(2, activation='softmax')(x1_3) y2_ = layers.Dense(2, activation='softmax')(x2_3) model = models.Model(inputs=[input1, input2], outputs=[y_connect_, y1_, y2_]) sgd = optimizers.SGD(lr=0.05, decay=1e-6, momentum=0.9, nesterov=True) #sgd = optimizers.SGD() model.compile(optimizer=sgd, loss=total_loss, metrics=['accuracy']) return model
def plot_intermediate_outputs(self, num_layers: int = 12, images_per_row: int = 12, save: bool = False): print('\nVisualizing the intermediate outputs of the first {} layers...'.format(num_layers)) if (save and check_existing_folder('outputs_visualization')) or not save: # Collect the name of the layers for the plot layer_names = [layer.name for layer in self.__model.layers[10:num_layers]] # Extract the outputs of the layers layer_outputs = [layer.output for layer in self.__model.layers[:num_layers]] # Create a model that will return the given outputs on the base of the model input activation_model = models.Model(inputs=self.__model.input, outputs=layer_outputs) # Perform a prediction on the test image using the new model activations = activation_model.predict(self.__img) # Display the activations in a grid self.__display_grid(layer_names, activations, images_per_row, save)
def get_model(): """ Creates our model with access to intermediate layers. This function will load the VGG19 model and access the intermediate layers. These layers will then be used to create a new model that will take input image and return the outputs from these intermediate layers from the VGG model. Returns: returns a keras model that takes image inputs and outputs the style and content intermediate layers. """ # Load our model. We load pretrained VGG, trained on imagenet data vgg = keras.applications.vgg19.VGG19(include_top=False, weights='imagenet') vgg.trainable = False # Get output layers corresponding to style and content layers style_outputs = [vgg.get_layer(name).output for name in style_layers] content_outputs = [vgg.get_layer(name).output for name in content_layers] model_outputs = style_outputs + content_outputs # Build model return models.Model(vgg.input, model_outputs)
def build_model(): sequences = layers.Input(shape=(MAX_LENGTH, )) embedded = layers.Embedding(MAX_FEATURES, 64)(sequences) x = layers.Conv1D(64, 3, activation='relu')(embedded) x = layers.BatchNormalization()(x) x = layers.MaxPool1D(3)(x) x = layers.Conv1D(64, 5, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.MaxPool1D(5)(x) x = layers.Conv1D(64, 5, activation='relu')(x) x = layers.GlobalMaxPool1D()(x) x = layers.Flatten()(x) x = layers.Dense(100, activation='relu')(x) predictions = layers.Dense(1, activation='sigmoid')(x) model = models.Model(inputs=sequences, outputs=predictions) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['binary_accuracy']) return model
def build_generator(self): dim = self.image_size[0] mult = dim // 8 x = inputs = layers.Input((1, 1, self.z_dim)) x = ops.UpConv2D(dim // 2 * mult, 4, 1, 'valid')(x) x = ops.BatchNorm()(x) x = layers.ReLU()(x) while mult > 1: x = ops.UpConv2D(dim // 2 * (mult // 2))(x) x = ops.BatchNorm()(x) x = layers.ReLU()(x) mult //= 2 x = ops.UpConv2D(3)(x) x = layers.Activation('tanh')(x) return models.Model(inputs, x, name='Generator')
def build_discriminator(self): dim = self.image_size[0] mult = 1 i = dim // 2 x = inputs = layers.Input((dim, dim, 3)) x = ops.Conv2D(dim // 2)(x) x = ops.LeakyRelu()(x) while i > 4: x = ops.Conv2D(dim // 2 * (2 * mult))(x) x = ops.LayerNorm(axis=[1, 2, 3])(x) x = ops.LeakyRelu()(x) i //= 2 mult *= 2 x = ops.Conv2D(1, 4, 1, 'valid')(x) return models.Model(inputs, x, name='Discriminator')
def network_1c(): """ BN+FC(512)+FC(6) (实验证明FC512效果优于FC1024) acc=0.96~0.99, size=841kb, time=0.03s :return: model """ inputs = kl.Input(shape=(8, 16, 1)) bone = kl.BatchNormalization(1)(inputs) bone = kl.Flatten()(bone) bone = kl.Dense(units=512, activation='relu')(bone) outputs = kl.Dense(units=6, activation='softmax')(bone) model = km.Model(inputs=inputs, outputs=outputs) model.summary() model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
def get_multiclass_model(depth, nclasses, optim, loss, mets, bias=None): """ Build a U-Net model Parameters: depth (int): number of training features (i.e. bands) nclasses (int): number of output classes optim (tf.keras.optimizer): keras optimizer loss (tf.keras.loss): keras or custom loss function mets (dict<tf.keras.metrics): dictionary of metrics for logits and classes. elements are lists of keras metrics Returns: tf.keras.model: compiled U-Net model """ if bias is not None: bias = tf.keras.initializers.Constant(bias) inputs = layers.Input(shape=[None, None, depth]) # 256 encoder0_pool, encoder0 = encoder_block(inputs, 32) # 128 encoder1_pool, encoder1 = encoder_block(encoder0_pool, 64) # 64 encoder2_pool, encoder2 = encoder_block(encoder1_pool, 128) # 32 encoder3_pool, encoder3 = encoder_block(encoder2_pool, 256) # 16 encoder4_pool, encoder4 = encoder_block(encoder3_pool, 512) # 8 center = conv_block(encoder4_pool, 1024) # center decoder4 = decoder_block(center, encoder4, 512) # 16 decoder3 = decoder_block(decoder4, encoder3, 256) # 32 decoder2 = decoder_block(decoder3, encoder2, 128) # 64 decoder1 = decoder_block(decoder2, encoder1, 64) # 128 decoder0 = decoder_block(decoder1, encoder0, 32) # 256 outputs = layers.Conv2D(nclasses, (1, 1), activation='softmax', name='softmax')(decoder0) # logits = layers.Conv2D(1, (1, 1), activation='sigmoid', bias_initializer = bias, name = 'logits')(decoder0) # logits is a probability and classes is binary. in solar, "tf.cast(tf.greater(x, 0.9)" was used to avoid too many false positives # classes = layers.Lambda(lambda x: tf.cast(tf.greater(x, 0.5), dtype = tf.int32), name = 'classes')(logits) # model = models.Model(inputs=[inputs], outputs=[logits, classes]) model = models.Model(inputs=[inputs], outputs=[outputs]) model.compile( optimizer=optim, loss={'softmax': loss}, #loss=losses.get(LOSS), metrics=mets) return model
def _get_keras_model(self) -> models.Model: I = layers.Input(shape=(None, self._embedding_size), dtype='float32', name=base_model.TOKENS_FEATURE_KEY) # Bidirectional GRU H = I for num_units in self.hparams().gru_units: H = layers.Bidirectional( layers.GRU(num_units, return_sequences=True))(I) # Attention last_gru_units = self.hparams( ).gru_units[-1] * 2 # x2 because bidirectional A = layers.TimeDistributed(layers.Dense(self.hparams().attention_units, activation='relu'), input_shape=(None, last_gru_units))(H) A = layers.TimeDistributed(layers.Dense(1))(A) A = layers.Flatten()(A) A = layers.Activation('softmax')(A) # Dense X = layers.Dot((1, 1))([H, A]) X = layers.Flatten()(X) for num_units in self.hparams().dense_units: X = layers.Dense(num_units, activation='relu')(X) X = layers.Dropout(self.hparams().dropout_rate)(X) # Outputs outputs = [] for label in self._labels: outputs.append( layers.Dense(1, activation='sigmoid', name=label)(X)) model = models.Model(inputs=I, outputs=outputs) model.compile( optimizer=optimizers.Adam(lr=self.hparams().learning_rate), loss='binary_crossentropy', metrics=['binary_accuracy', super().roc_auc]) tf.logging.info(model.summary()) return model
def build_model(self): """Build an actor (policy) network that maps states -> actions.""" # Define input layer (states) states = layers.Input(shape=(self.state_size, ), name='states') # Add hidden layers net = layers.Dense(units=32, activation='relu')(states) net = layers.Dropout(0.8)(net) net = layers.Dense(units=64, activation='relu')(net) net = layers.Dropout(0.8)(net) net = layers.Dense(units=32, activation='relu')(net) # Try different layer sizes, activations, add batch normalization, regularizers, etc. # Add final output layer with sigmoid activation raw_actions = layers.Dense(units=self.action_size, activation='sigmoid', name='raw_actions')(net) # Scale [0, 1] output for each action dimension to proper range actions = layers.Lambda(lambda x: (x * self.action_range) + self.action_low, name='actions')(raw_actions) # Create Keras model self.model = models.Model(inputs=states, outputs=actions) # Define loss function using action value (Q value) gradients action_gradients = layers.Input(shape=(self.action_size, )) loss = K.mean(-action_gradients * actions) # Incorporate any additional losses here (e.g. from regularizers) # Define optimizer and training function optimizer = optimizers.Adam(lr=0.0001) updates_op = optimizer.get_updates(params=self.model.trainable_weights, loss=loss) self.train_fn = K.function( inputs=[self.model.input, action_gradients, K.learning_phase()], outputs=[], updates=updates_op)
def test_save_weights_with_dynamic_loss_scaling(self, strategy_fn): if not self._is_strategy_supported(strategy_fn): return strategy = strategy_fn() if (isinstance(strategy, mirrored_strategy.MirroredStrategy) and not context.executing_eagerly()): # TODO(b/121381184): Enable running the test in this case. return # Create and run model. with strategy.scope(): x = layers.Input(shape=(2, ), batch_size=2, dtype=dtypes.float32) y = AddLayer(assert_type=dtypes.float32)(x) model = models.Model(inputs=x, outputs=y) loss_scale = loss_scale_module.DynamicLossScale( initial_loss_scale=1., increment_period=2., multiplier=2.) opt = gradient_descent.SGD(1.) opt = loss_scale_optimizer.LossScaleOptimizer(opt, loss_scale) model.compile( optimizer=opt, loss='mse', run_eagerly=testing_utils.should_run_eagerly(), run_distributed=testing_utils.should_run_distributed()) # Run for 3 steps (6 examples with a batch size of 2) model.fit(np.zeros((6, 2)), np.zeros((6, 2)), batch_size=2) self.assertEqual(backend.get_value(loss_scale()), 2) self.assertEqual(backend.get_value(loss_scale._num_good_steps), 1) # Save model weights. save_prefix = os.path.join(self.get_temp_dir(), 'ckpt') model.save_weights(save_prefix) # Run model again for 1 step (2 examples with a batch size of 2) model.fit(np.zeros((2, 2)), np.zeros((2, 2)), batch_size=2) self.assertEqual(backend.get_value(loss_scale()), 4) self.assertEqual(backend.get_value(loss_scale._num_good_steps), 0) # Load model weights and ensure loss scale weights are restored. model.load_weights(save_prefix) self.assertEqual(backend.get_value(loss_scale()), 2) self.assertEqual(backend.get_value(loss_scale._num_good_steps), 1)
def encoder_decoder_model(img_shape, reg_enc=False, reg_dec=False): """Simple encoding decoding model (UNet). Encodes by factor 2**4 and decodes back. Arguments: img_shape: image shape as (height, width, channels) reg_enc: regularize encoding reg_dec: regularize decoding Returns: a keras model """ inputs = layers.Input(shape=img_shape) # (256,256,3) encoder0 = encoder_block(inputs, 32, pool=False, reg=reg_enc) # (256,256,32) encoder1 = encoder_block(encoder0, 64, reg=reg_enc) # (128,128,64) encoder2 = encoder_block(encoder1, 128, reg=reg_enc) # (64,64,128) encoder3 = encoder_block(encoder2, 256, reg=reg_enc) # (32,32,256) encoder4 = encoder_block(encoder3, 512, reg=reg_enc) # (16,16,512) center = encoder_block(encoder4, 1024, reg=reg_enc) # (8,8,1024) decoder4 = decoder_block(center, encoder4, 512, reg=reg_dec) # (16,16,512) decoder3 = decoder_block(decoder4, encoder3, 256, reg=reg_dec) # (32,32,256) decoder2 = decoder_block(decoder3, encoder2, 128, reg=reg_dec) # (64,64,128) decoder1 = decoder_block(decoder2, encoder1, 64, reg=reg_dec) # (128,128,64) decoder0 = decoder_block(decoder1, encoder0, 32, reg=reg_dec) # (256,256,32) outputs = layers.Conv2D(1, (1, 1), activation='sigmoid')(decoder0) # (256,256,1) model = models.Model(inputs=[inputs], outputs=[outputs]) return model
def build_model(self): if self.name == 'VGG19': # Load our model. We load pretrained VGG, trained on imagenet data vgg = tf.keras.applications.vgg19.VGG19(include_top=False, weights='imagenet') vgg.trainable = False # Get output layers corresponding to style and content layers style_outputs = [ vgg.get_layer(name).output for name in self.style_feat_layers ] content_outputs = [ vgg.get_layer(name).output for name in self.content_feat_layers ] model_outputs = style_outputs + content_outputs # Build model else: print("Error: Not Support this model! Please Check!") self.model = models.Model(vgg.input, model_outputs) print(self.model.summary())
def get_model(img_shape): inputs = layers.Input(shape=img_shape) encoder0_pool, encoder0 = encoder_block(inputs, 8) encoder1_pool, encoder1 = encoder_block(encoder0_pool, 16) encoder2_pool, encoder2 = encoder_block(encoder1_pool, 32) encoder3_pool, encoder3 = encoder_block(encoder2_pool, 64) center = conv_block(encoder3_pool, 128) decoder3 = decoder_block(center, encoder3, 64) decoder2 = decoder_block(decoder3, encoder2, 32) decoder1 = decoder_block(decoder2, encoder1, 16) decoder0 = decoder_block(decoder1, encoder0, 8) outputs = layers.Conv2D(1, (1, 1), activation='sigmoid')(decoder0) model = models.Model(inputs=[inputs], outputs=[outputs]) return model
def build_model(self) -> keras_models.Model: input_shape = keras_layers.Input(shape=(None, None, 3)) kernel_size = (3, 3) x = input_shape for type_, name, filters in self.layers: if type_ == 'conv': x = self._get_conv_layer(filters, kernel_size, name)(x) else: pass # TODO max pooling # create model model = keras_models.Model(input_shape, x, name='vgg19') # load weight weight_path = self._get_weight() model.load_weights(weight_path) return model
def get_model(): """Creates a model with access to intermediate layers. These layers will then be used to create a new model that will take the content image and return the outputs from these intermediate layers from the VGG model. Returns: A keras model that takes image inputs and outputs the style and content intermediate layers. """ vgg = vgg19.VGG19(include_top=False, weights='imagenet') vgg.trainable = False style_outputs = [vgg.get_layer(name).output for name in style_layers] content_outputs = [vgg.get_layer(name).output for name in content_layers] model_outputs = style_outputs + content_outputs return models.Model(vgg.input, model_outputs)
def test_save_weights_with_autocast_vars(self, strategy_fn, h5=False): with strategy_fn().scope(): with policy.policy_scope('mixed_float16'): x = layers.Input(shape=(1, ), batch_size=2) layer = mp_test_util.MultiplyLayer(assert_type=dtypes.float16) y = layer(x) model = models.Model(inputs=x, outputs=y) model.set_weights([np.array(100.)]) x = np.ones((2, 1)) self.assertAllClose(backend.get_value(model(x)), x * 100.) suffix = '.h5' if h5 else '' weights_file = os.path.join(self.get_temp_dir(), 'weights' + suffix) model.save_weights(weights_file) model.set_weights([np.array(200.)]) self.assertAllClose(backend.get_value(model(x)), x * 200.) model.load_weights(weights_file) self.assertAllClose(backend.get_value(model(x)), x * 100.) self.assertEqual(model.get_weights(), [np.array(100.)])
def make_decoder_model(input_tensor=None, input_shape=(28, 28, 1)): """ Create a decoder model Args: input_tensor: It's going to be tensor, which is going to be the array input_shape: image tensor size. Returns: tf.keras.Model """ if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = layers.Dense(7 * 7 * 64, activation=tf.nn.relu, name="den1")(img_input) x = layers.Reshape(target_shape=(7, 7, 64), name="reshape1")(x) x = layers.Conv2DTranspose(64, (3, 3), strides=(2, 2), padding="SAME", activation=tf.nn.relu, name="convt1")(x), x = layers.Conv2DTranspose(32, (3, 3), strides=(2, 2), padding="SAME", activation=tf.nn.relu, name="convt2")(x), x = layers.Conv2DTranspose(1, (3, 3), strides=(1, 1), padding="SAME", activation=tf.nn.sigmoid, name="convt3")(x), if input_tensor is not None: inputs = utils.get_source_inputs(input_tensor) else: inputs = img_input model = models.Model(inputs, x, name='Decoder_model') return model
def make_model(env): original_matrix = np.genfromtxt(PATH_TO_CSV, delimiter=",", skip_header=39) stateCnt = original_matrix.shape[1] #input_shape = (10, stateCnt) # dataframe1 = pd.read_csv(PATH_TO_CSV, header=None, usecols=range(0,67), skiprows=39, engine='python') #dataframe.assign(s=dataframe.s.shift(-1)).drop(dataframe.index[-1]) #dataframe[dataframe.columns[-1]] = dataframe[dataframe.columns[-1]].shift(-1) # dataframe1 = dataframe1[-1000:] # dataset1 = dataframe1.values # dataset1 = dataset1.astype('float64') #UNCOMMENT THIS TO SCALE ACCORDING TO CURRENT DATA # from sklearn import preprocessing # scaler1 = preprocessing.MinMaxScaler() # X1 = dataset1[:,0:67] #scaler1.fit(X1) # X1 = scaler1.transform(X1) # input_shape = X1.reshape(-1,10,67) #input_shape = observation_space # input_shape = np.reshape(-1,10,67) # num_frames = len(env.observation_space.spaces) # height, width = env.observation_space.spaces[0].shape # input_shape = height, width, num_frames input_shape=(10, stateCnt) ph_state = layers.Input(shape=input_shape) # conv1 = layers.Conv2D(32, (8, 8), strides=(4, 4))(ph_state) conv1 = layers.Conv1D(filters=2, kernel_size=1)(ph_state) conv1 = layers.Activation('relu')(conv1) # conv2 = layers.Conv2D(64, (4, 4), strides=(2, 2))(conv1) # conv2 = layers.Activation('relu')(conv2) # conv3 = layers.Conv2D(64, (3, 3), strides=(1, 1))(conv2) # conv3 = layers.Activation('relu')(conv3) conv_flat = layers.Flatten()(conv1) feature = layers.Dense(512)(conv_flat) feature = layers.Activation('relu')(feature) # actor (policy) and critic (value) streams size_logits = 4 size_value = 4 logits_init = initializers.RandomNormal(stddev=1e-3) logits = layers.Dense(size_logits, kernel_initializer=logits_init)(feature) value = layers.Dense(size_value)(feature) return models.Model(inputs=ph_state, outputs=[logits, value])
def build_model(self): """Build a critic (value) network that maps (state, action) pairs -> Q-values.""" # Define input layers states = layers.Input(shape=(self.state_size, ), name='states') actions = layers.Input(shape=(self.action_size, ), name='actions') # Add hidden layer(s) for state pathway net_states = layers.Dense(units=32, activation='relu')(states) net_states = layers.Dropout(0.8)(net_states) net_states = layers.Dense(units=64, activation='relu')(net_states) net_states = layers.Dropout(0.8)(net_states) # Add hidden layer(s) for action pathway net_actions = layers.Dense(units=32, activation='relu')(actions) net_actions = layers.Dense(units=64, activation='relu')(net_actions) # Try different layer sizes, activations, add batch normalization, regularizers, etc. # Combine state and action pathways net = layers.Add()([net_states, net_actions]) net = layers.Activation('relu')(net) # Add more layers to the combined network if needed # Add final output layer to prduce action values (Q values) Q_values = layers.Dense(units=1, name='q_values')(net) # Create Keras model self.model = models.Model(inputs=[states, actions], outputs=Q_values) # Define optimizer and compile model for training with built-in loss function optimizer = optimizers.Adam(lr=0.0001) self.model.compile(optimizer=optimizer, loss='mse') # Compute action gradients (derivative of Q values w.r.t. to actions) action_gradients = K.gradients(Q_values, actions) # Define an additional function to fetch action gradients (to be used by actor model) self.get_action_gradients = K.function( inputs=[*self.model.input, K.learning_phase()], outputs=action_gradients)
def get_model256(): inputs = layers.Input(shape=(256, 256, 3)) # 256 encoder0_pool, encoder0 = encoder_block(inputs, 32) # 128 encoder1_pool, encoder1 = encoder_block(encoder0_pool, 64) # 64 encoder2_pool, encoder2 = encoder_block(encoder1_pool, 128) # 32 encoder3_pool, encoder3 = encoder_block(encoder2_pool, 256) # 16 encoder4_pool, encoder4 = encoder_block(encoder3_pool, 512) # 8 center = conv_block(encoder4_pool, 1024) # center decoder4 = decoder_block(center, encoder4, 512) # 16 decoder3 = decoder_block(decoder4, encoder3, 256) # 32 decoder2 = decoder_block(decoder3, encoder2, 128) # 64 decoder1 = decoder_block(decoder2, encoder1, 64) # 128 decoder0 = decoder_block(decoder1, encoder0, 32) # 256 outputs = layers.Conv2D(1, (1, 1), activation='sigmoid')(decoder0) model = models.Model(inputs=[inputs], outputs=[outputs]) return model
def test_model(self, strategy_fn, use_operator=False, use_regularizer=False, cloning=True): if not self._is_strategy_supported(strategy_fn): return regularizer = IdentityRegularizer() if use_regularizer else None with strategy_fn().scope(): with policy.policy_scope('infer_float32_vars'): x = layers.Input(shape=(1,), batch_size=2, dtype=dtypes.float16) layer = AddLayer(assert_type=dtypes.float16, use_operator=use_operator, regularizer=regularizer) y = layer(x) y = math_ops.cast(y, dtypes.float32) model = models.Model(inputs=x, outputs=y) def loss_fn(y_true, y_pred): del y_true return math_ops.reduce_mean(y_pred) # Learning rate is small enough that if applied to a float16 variable, # the variable will not change. So this tests the learning rate not # applied to a float16 value, but instead the float32 variable. opt = gradient_descent.SGD(2 ** -14) model.compile( opt, loss=loss_fn, cloning=cloning, run_eagerly=testing_utils.should_run_eagerly(), run_distributed=testing_utils.should_run_distributed()) self.assertEqual(backend.eval(layer.v), 1) x = np.ones((2, 1)) y = np.ones((2, 1)) dataset = dataset_ops.Dataset.from_tensor_slices((x, y)).batch(2) model.fit(dataset) # Variable starts at 1, and should have gradient of 2 ** -14 subtracted # from it. expected = 1 - 2 ** -14 if use_regularizer: # Regularizer adds another 2 ** -14 to the gradient. expected -= 2 ** -14 self.assertEqual(backend.eval(layer.v), expected)
def quick_eval(params,save_model_path): img_dir = os.path.join(params["data_dir"], "test_images") label_dir = os.path.join(params["data_dir"], "test_labels") ids_train = [i.replace(".png","") for i in os.listdir(img_dir)] x_train_filenames = [] y_train_filenames = [] for img_id in ids_train: x_train_filenames.append(os.path.join(img_dir, "{}.png".format(img_id))) y_train_filenames.append(os.path.join(label_dir, "{}.png".format(img_id))) y_val_filenames = y_train_filenames x_val_filenames = x_train_filenames num_train_examples = len(x_train_filenames) num_val_examples = len(x_val_filenames) print("Number of training examples: {}".format(num_train_examples)) print("Number of validation examples: {}".format(num_val_examples)) # Alternatively, load the weights directly: model.load_weights(save_model_path) from keras.models import load_model inputs, outputs = model_fn(params["img_shape"]) model = models.Model(inputs=[inputs], outputs=[outputs]) model.load_weights(save_model_path) train_ds,val_ds,temp_ds = batch_data_sets(x_train_filenames,y_train_filenames,x_val_filenames,y_val_filenames) # Let's visualize some of the outputs data_aug_iter = val_ds.make_one_shot_iterator() next_element = data_aug_iter.get_next() # Running next element in our graph will produce a batch of images test_losses = [] for i in range(12): batch_of_imgs, label = tf.keras.backend.get_session().run(next_element) img = batch_of_imgs[0] loss = model.evaluate(x=batch_of_imgs, y=label, batch_size=1, verbose=1, sample_weight=None, steps=None) test_losses.append(loss) print("average dice score over all samples are:{}".format(np.mean(test_losses)))
def test_save_weights(self, strategy_fn, h5=False): with strategy_fn().scope(): with policy.policy_scope('infer_float32_vars'): x = layers.Input(shape=(), batch_size=2, dtype=dtypes.float16) layer = AddLayer(assert_type=dtypes.float16) y = layer(x) y = math_ops.cast(y, dtypes.float32) model = models.Model(inputs=x, outputs=y) model.set_weights([np.array(100.)]) x = np.ones((2, 1), dtype=np.float16) self.assertAllClose(backend.get_value(model(x)), x + 100.) suffix = '.h5' if h5 else '' weights_file = os.path.join(self.get_temp_dir(), 'weights' + suffix) model.save_weights(weights_file) model.set_weights([np.array(200.)]) self.assertAllClose(backend.get_value(model(x)), x + 200.) model.load_weights(weights_file) self.assertAllClose(backend.get_value(model(x)), x + 100.) self.assertEqual(model.get_weights(), [np.array(100.)])
def get_model(): # 内容层选取 block5_conv2 content_layers = ['block5_conv2'] # 风格层 conv1 style_layers = ['block1_conv1', 'block2_conv1', 'block3_conv1', 'block4_conv1', 'block5_conv1'] # 导入VGG19模型,权重使用imagenet vgg = tf.keras.applications.vgg19.VGG19(include_top=False, weights='imagenet') vgg.trainable = False # 提取风格特征 style_outputs = [vgg.get_layer(name).output for name in style_layers] # 提取内容特征 content_outputs = [vgg.get_layer(name).output for name in content_layers] # 输出结果特征 model_outputs = style_outputs + content_outputs return models.Model(vgg.input, model_outputs)