def model_builder(hp): #build a CNN dense = keras.layers.Dense(units=16) # Let's say we expect our inputs to be RGB images of arbitrary size inputs = keras.Input(shape=(None, None, 3)) from tensorflow.keras import layers # Center-crop images to 101 x 200 to fit sample size x = CenterCrop(height=101, width=200)(inputs) # Rescale images to [0, 1] x = Rescaling(scale=1./255)(x) # Apply some convolution and pooling layers x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='SAME', activation='relu')(x) x = layers.MaxPooling2D(pool_size=(3, 3))(x) x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='SAME', activation='relu')(x) # Apply global average pooling to get flat feature vectors x = layers.GlobalAveragePooling2D()(x) # add a dense layer x = layers.Dense(20, activation='relu')(x) # Add a dense classifier on top num_classes = 10 outputs = layers.Dense(num_classes, activation='softmax')(x) model = keras.Model(inputs=inputs, outputs=outputs) model.summary() # Tune the learning rate for the optimizer # Choose an optimal value from 0.01, 0.001, or 0.0001 hp_learning_rate = hp.Choice('learning_rate', values = [1e-2, 1e-3, 1e-4]) #compile and keep metrics model.compile(optimizer=keras.optimizers.Adam(learning_rate = hp_learning_rate), loss=keras.losses.SparseCategoricalCrossentropy(from_logits = True), metrics=[keras.metrics.SparseCategoricalAccuracy(name='acc')]) #model.fit(x_train, y_train, batch_size=32, epochs=10) return model
def make_model(metrics=METRICS, output_bias=None): if output_bias is not None: output_bias = tf.keras.initializers.Constant(output_bias) inputs = keras.Input(shape=(None, None, 3)) targetsize = 512 from tensorflow.keras import layers import math # 1D cropping to fit sample size x = CenterCrop(height=1, width=targetsize)(inputs) #print(x.shape) # Rescale images to [0, 1] x = Rescaling(scale=1. / 255)(inputs) # Apply some convolution and pooling layers x = layers.Conv2D(filters=32, kernel_size=3, strides=2, padding='SAME', activation='relu')(x) x = layers.Conv2D(filters=32, kernel_size=3, strides=2, padding='SAME', activation='relu')(x) x = layers.Conv2D(filters=32, kernel_size=3, strides=2, padding='SAME', activation='relu')(x) # Apply global average pooling to get flat feature vectors x = layers.GlobalAveragePooling2D()(x) # add a dense layer x = layers.Dense(16, activation='relu')(x) # Add a dense classifier on top num_classes = 3 outputs = layers.Dense(num_classes, activation='sigmoid', bias_initializer=output_bias)(x) model = keras.Model(inputs=inputs, outputs=outputs) model.summary() model.compile(optimizer=keras.optimizers.Adam(lr=1e-3), loss=keras.losses.BinaryCrossentropy(), metrics=metrics) return model
def __init__(self, path_cartoon_dataset, path_real_faces_dataset, batch_size): # Image cropper self.cropper = CenterCrop(height=64, width=64) self.training_cartoon = tf.keras.preprocessing.image_dataset_from_directory( path_cartoon_dataset, image_size=(83, 83), batch_size=batch_size, label_mode=None, shuffle=True) self.training_cartoon = self.training_cartoon.map( self.preprocessing_image) self.training_face = tf.keras.preprocessing.image_dataset_from_directory( path_real_faces_dataset, image_size=(83, 83), batch_size=batch_size, label_mode=None, shuffle=True) self.training_face = self.training_face.map(self.preprocessing_image) self.dataset_numpy = self.join_datasets_to_numpy()
print("mean: %.4f" % np.mean(normalized_data)) """ **Example: rescaling & center-cropping images** Both the `Rescaling` layer and the `CenterCrop` layer are stateless, so it isn't necessary to call `adapt()` in this case. """ from tensorflow.keras.layers.experimental.preprocessing import CenterCrop from tensorflow.keras.layers.experimental.preprocessing import Rescaling # Example image data, with values in the [0, 255] range training_data = np.random.randint(0, 256, size=(64, 200, 200, 3)).astype("float32") cropper = CenterCrop(height=150, width=150) scaler = Rescaling(scale=1.0 / 255) output_data = scaler(cropper(training_data)) print("shape:", output_data.shape) print("min:", np.min(output_data)) print("max:", np.max(output_data)) """ ## Building models with the Keras Functional API A "layer" is a simple input-output transformation (such as the scaling & center-cropping transformations above). For instance, here's a linear projection layer that maps its inputs to a 16-dimensional feature space: ```python dense = keras.layers.Dense(units=16)
def main( root_dir: str, split: str, input_shape: Tuple[int, int, int], n_classes: int, margin: float, scale: float, embedding_dimension: int, momentum: float, weight_decay: float, batch_size: int, epochs: int, seed: int, model_path: str, precision_policy: Optional[str] = None, **kwargs, ): set_gpu_memory_growth() if precision_policy is None: precision_policy = "float32" policy = tf.keras.mixed_precision.Policy(precision_policy) tf.keras.mixed_precision.set_global_policy(policy) read_config = tfds.ReadConfig(shuffle_seed=seed) builder = tfds.ImageFolder(root_dir) ds: tf.data.Dataset = builder.as_dataset( split=split, batch_size=batch_size, shuffle_files=True, decoders={"label": onehot_encoding(depth=n_classes)}, read_config=read_config, as_supervised=True, ) height, width, n_channels = input_shape data_augmentation = tf.keras.Sequential([ RandomRotation(factor=0.05, fill_mode="nearest", seed=seed), RandomTranslation(height_factor=0.1, width_factor=0.1, fill_mode="wrap", seed=seed), RandomZoom(height_factor=0.1, fill_mode="reflect", seed=seed), RandomContrast(factor=0.1, seed=seed), CenterCrop(height=height, width=width), ]) ds = (ds.map(lambda x, y: (preprocess_input(x), y), num_parallel_calls=AUTOTUNE).map( lambda x, y: (data_augmentation(x), y), num_parallel_calls=AUTOTUNE).unbatch()) valid_size = 1000 valid_ds = ds.take(valid_size).batch(batch_size).prefetch(AUTOTUNE) train_ds = (ds.skip(valid_size).shuffle(buffer_size=100000).batch( batch_size, drop_remainder=True).prefetch(AUTOTUNE)) model = create_model( input_shape=input_shape, n_classes=n_classes, embedding_dimension=embedding_dimension, weights_decay=weight_decay, use_pretrain=False, ) optimizer = tf.keras.optimizers.SGD(momentum=momentum) model_checkpoint = ModelCheckpoint( # "./model/weights.{epoch:03d}-{val_loss:.3f}.hdf5", model_path, monitor="val_loss", save_best_only=True, ) def scheduler(epoch, lr): if epoch < 30: return 1e-1 elif epoch < 60: return 1e-2 elif epoch < 90: return 1e-3 else: return 1e-4 lr_scheduler = tf.keras.callbacks.LearningRateScheduler(scheduler) tensorboard_callback = tf.keras.callbacks.TensorBoard(histogram_freq=1) model.compile( optimizer=optimizer, loss=ClippedValueLoss( loss_func=AdditiveAngularMarginLoss( loss_func=tf.keras.losses.CategoricalCrossentropy(), margin=margin, scale=scale, dtype=policy.compute_dtype, ), x_min=tf.keras.backend.epsilon(), x_max=1.0, ), metrics=[tf.keras.metrics.CategoricalAccuracy()], ) model.fit( train_ds, batch_size=batch_size, epochs=epochs, validation_data=valid_ds, callbacks=[ model_checkpoint, lr_scheduler, tensorboard_callback, ], verbose=1, )
import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras.layers.experimental.preprocessing import CenterCrop, Rescaling training_data = np.random.randint(0, 256, size=(64, 200, 200, 3)).astype("float32") cropper = CenterCrop(height=150, width=150) scaler = Rescaling(scale=1.0 / 255) output_data = scaler(cropper(training_data)) print("shape:", output_data.shape) print("min:", np.min(output_data)) print("max:", np.max(output_data))
import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras.layers.experimental.preprocessing import CenterCrop from tensorflow.keras.layers.experimental.preprocessing import Rescaling #build a CNN dense = keras.layers.Dense(units=16) # Let's say we expect our inputs to be RGB images of arbitrary size inputs = keras.Input(shape=(None, None, 3)) from tensorflow.keras import layers # Center-crop images to 101 x 200 to fit sample size x = CenterCrop(height=101, width=200)(inputs) # Rescale images to [0, 1] x = Rescaling(scale=1./255)(x) # Apply some convolution and pooling layers x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='SAME', activation='relu')(x) x = layers.MaxPooling2D(pool_size=(3, 3))(x) x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='SAME', activation='relu')(x) # Apply global average pooling to get flat feature vectors x = layers.GlobalAveragePooling2D()(x) # add a dense layer x = layers.Dense(20, activation='relu')(x) # Add a dense classifier on top num_classes = 10 outputs = layers.Dense(num_classes, activation='softmax')(x) model = keras.Model(inputs=inputs, outputs=outputs) model.summary() #compile and keep metrics model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',metrics=[keras.metrics.SparseCategoricalAccuracy(name='acc')])
directory="./miml_dataset/images", x_col="Filenames", batch_size=1, seed=42, shuffle=False, class_mode=None, target_size=(100,100)) # Let's say we expect our inputs to be RGB images of arbitrary size inputs = keras.Input(shape=(None,None,3)) targetsize=512 from tensorflow.keras import layers import math # 1D cropping to fit sample size x = CenterCrop(height=1,width=targetsize)(inputs) #print(x.shape) # Rescale images to [0, 1] x = Rescaling(scale=1./255)(inputs) # Apply some convolution and pooling layers x = layers.Conv2D(filters=32, kernel_size=3, strides=2, padding='SAME', activation='relu')(x) x = layers.Conv2D(filters=32, kernel_size=3, strides=2, padding='SAME', activation='relu')(x) x = layers.Conv2D(filters=32, kernel_size=3, strides=2, padding='SAME', activation='relu')(x) # Apply global average pooling to get flat feature vectors x = layers.GlobalAveragePooling2D()(x) # add a dense layer x = layers.Dense(16, activation='relu')(x) # Add a dense classifier on top num_classes = 3 outputs = layers.Dense(num_classes, activation='sigmoid')(x) model = keras.Model(inputs=inputs, outputs=outputs)