Training a CTC-based model for automatic speech recognition. Introduction Speech recognition is an interdisciplinary subfield of computer science and computational linguistics that develops methodologies and technologies that enable the recognition and translation of spoken language into text by computers. It is also known as automatic speech recognition (ASR), computer speech recognition or speech to text (STT). It incorporates knowledge and research in the computer science, linguistics and computer engineering fields. This demonstration shows how to combine a 2D CNN, RNN and a Connectionist Temporal Classification (CTC) loss to build an ASR. CTC is an algorithm used to train deep neural networks in speech recognition, handwriting recognition and other sequence problems. CTC is used when we don’t know how the input aligns with the output (how the characters in the transcript align to the audio). The model we create is similar to DeepSpeech2. We will use the LJSpeech dataset from the LibriVox project. It consists of short audio clips of a single speaker reading passages from 7 non-fiction books. We will evaluate the quality of the model using Word Error Rate (WER). WER is obtained by adding up the substitutions, insertions, and deletions that occur in a sequence of recognized words. Divide that number by the total number of words originally spoken. The result is the WER. To get the WER score you need to install the jiwer package. You can use the following command line: pip install jiwer References: LJSpeech Dataset Speech recognition Sequence Modeling With CTC DeepSpeech2 Setup import pandas as pd import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import matplotlib.pyplot as plt from IPython import display from jiwer import wer Load the LJSpeech Dataset Let's download the LJSpeech Dataset. The dataset contains 13,100 audio files as wav files in the /wavs/ folder. The label (transcript) for each audio file is a string given in the metadata.csv file. The fields are: ID: this is the name of the corresponding .wav file Transcription: words spoken by the reader (UTF-8) Normalized transcription: transcription with numbers, ordinals, and monetary units expanded into full words (UTF-8). For this demo we will use on the \"Normalized transcription\" field. Each audio file is a single-channel 16-bit PCM WAV with a sample rate of 22,050 Hz. data_url = \"https://data.keithito.com/data/speech/LJSpeech-1.1.tar.bz2\" data_path = keras.utils.get_file(\"LJSpeech-1.1\", data_url, untar=True) wavs_path = data_path + \"/wavs/\" metadata_path = data_path + \"/metadata.csv\" # Read metadata file and parse it metadata_df = pd.read_csv(metadata_path, sep=\"|\", header=None, quoting=3) metadata_df.columns = [\"file_name\", \"transcription\", \"normalized_transcription\"] metadata_df = metadata_df[[\"file_name\", \"normalized_transcription\"]] metadata_df = metadata_df.sample(frac=1).reset_index(drop=True) metadata_df.head(3) file_name normalized_transcription 0 LJ042-0218 to the entire land and complete foundations of... 1 LJ004-0218 a week's allowance at a time, was abolished, a... 2 LJ005-0151 in others women were very properly exempted fr... We now split the data into training and validation set. split = int(len(metadata_df) * 0.90) df_train = metadata_df[:split] df_val = metadata_df[split:] print(f\"Size of the training set: {len(df_train)}\") print(f\"Size of the training set: {len(df_val)}\") Size of the training set: 11790 Size of the training set: 1310 Preprocessing We first prepare the vocabulary to be used. # The set of characters accepted in the transcription. characters = [x for x in \"abcdefghijklmnopqrstuvwxyz'?! \"] # Mapping characters to integers char_to_num = keras.layers.StringLookup(vocabulary=characters, oov_token=\"\") # Mapping integers back to original characters num_to_char = keras.layers.StringLookup( vocabulary=char_to_num.get_vocabulary(), oov_token=\"\", invert=True ) print( f\"The vocabulary is: {char_to_num.get_vocabulary()} \" f\"(size ={char_to_num.vocabulary_size()})\" ) The vocabulary is: ['', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', \"'\", '?', '!', ' '] (size =31) 2021-09-28 21:16:33.150832: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. 2021-09-28 21:16:33.692813: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:39] Overriding allow_growth setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0. 2021-09-28 21:16:33.692847: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 9124 MB memory: -> device: 0, name: GeForce RTX 2080 Ti, pci bus id: 0000:65:00.0, compute capability: 7.5 Next, we create the function that describes the transformation that we apply to each element of our dataset. # An integer scalar Tensor. The window length in samples. frame_length = 256 # An integer scalar Tensor. The number of samples to step. frame_step = 160 # An integer scalar Tensor. The size of the FFT to apply. # If not provided, uses the smallest power of 2 enclosing frame_length. fft_length = 384 def encode_single_sample(wav_file, label): ########################################### ## Process the Audio ########################################## # 1. Read wav file file = tf.io.read_file(wavs_path + wav_file + \".wav\") # 2. Decode the wav file audio, _ = tf.audio.decode_wav(file) audio = tf.squeeze(audio, axis=-1) # 3. Change type to float audio = tf.cast(audio, tf.float32) # 4. Get the spectrogram spectrogram = tf.signal.stft( audio, frame_length=frame_length, frame_step=frame_step, fft_length=fft_length ) # 5. We only need the magnitude, which can be derived by applying tf.abs spectrogram = tf.abs(spectrogram) spectrogram = tf.math.pow(spectrogram, 0.5) # 6. normalisation means = tf.math.reduce_mean(spectrogram, 1, keepdims=True) stddevs = tf.math.reduce_std(spectrogram, 1, keepdims=True) spectrogram = (spectrogram - means) / (stddevs + 1e-10) ########################################### ## Process the label ########################################## # 7. Convert label to Lower case label = tf.strings.lower(label) # 8. Split the label label = tf.strings.unicode_split(label, input_encoding=\"UTF-8\") # 9. Map the characters in label to numbers label = char_to_num(label) # 10. Return a dict as our model is expecting two inputs return spectrogram, label Creating Dataset objects We create a tf.data.Dataset object that yields the transformed elements, in the same order as they appeared in the input. batch_size = 32 # Define the trainig dataset train_dataset = tf.data.Dataset.from_tensor_slices( (list(df_train[\"file_name\"]), list(df_train[\"normalized_transcription\"])) ) train_dataset = ( train_dataset.map(encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE) .padded_batch(batch_size) .prefetch(buffer_size=tf.data.AUTOTUNE) ) # Define the validation dataset validation_dataset = tf.data.Dataset.from_tensor_slices( (list(df_val[\"file_name\"]), list(df_val[\"normalized_transcription\"])) ) validation_dataset = ( validation_dataset.map(encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE) .padded_batch(batch_size) .prefetch(buffer_size=tf.data.AUTOTUNE) ) Visualize the data Let's visualize an example in our dataset, including the audio clip, the spectrogram and the corresponding label. fig = plt.figure(figsize=(8, 5)) for batch in train_dataset.take(1): spectrogram = batch[0][0].numpy() spectrogram = np.array([np.trim_zeros(x) for x in np.transpose(spectrogram)]) label = batch[1][0] # Spectrogram label = tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\") ax = plt.subplot(2, 1, 1) ax.imshow(spectrogram, vmax=1) ax.set_title(label) ax.axis(\"off\") # Wav file = tf.io.read_file(wavs_path + list(df_train[\"file_name\"])[0] + \".wav\") audio, _ = tf.audio.decode_wav(file) audio = audio.numpy() ax = plt.subplot(2, 1, 2) plt.plot(audio) ax.set_title(\"Signal Wave\") ax.set_xlim(0, len(audio)) display.display(display.Audio(np.transpose(audio), rate=16000)) plt.show() 2021-09-28 21:16:34.014170: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2) png Model We first define the CTC Loss function. def CTCLoss(y_true, y_pred): # Compute the training-time loss value batch_len = tf.cast(tf.shape(y_true)[0], dtype=\"int64\") input_length = tf.cast(tf.shape(y_pred)[1], dtype=\"int64\") label_length = tf.cast(tf.shape(y_true)[1], dtype=\"int64\") input_length = input_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\") label_length = label_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\") loss = keras.backend.ctc_batch_cost(y_true, y_pred, input_length, label_length) return loss We now define our model. We will define a model similar to DeepSpeech2. def build_model(input_dim, output_dim, rnn_layers=5, rnn_units=128): \"\"\"Model similar to DeepSpeech2.\"\"\" # Model's input input_spectrogram = layers.Input((None, input_dim), name=\"input\") # Expand the dimension to use 2D CNN. x = layers.Reshape((-1, input_dim, 1), name=\"expand_dim\")(input_spectrogram) # Convolution layer 1 x = layers.Conv2D( filters=32, kernel_size=[11, 41], strides=[2, 2], padding=\"same\", use_bias=False, name=\"conv_1\", )(x) x = layers.BatchNormalization(name=\"conv_1_bn\")(x) x = layers.ReLU(name=\"conv_1_relu\")(x) # Convolution layer 2 x = layers.Conv2D( filters=32, kernel_size=[11, 21], strides=[1, 2], padding=\"same\", use_bias=False, name=\"conv_2\", )(x) x = layers.BatchNormalization(name=\"conv_2_bn\")(x) x = layers.ReLU(name=\"conv_2_relu\")(x) # Reshape the resulted volume to feed the RNNs layers x = layers.Reshape((-1, x.shape[-2] * x.shape[-1]))(x) # RNN layers for i in range(1, rnn_layers + 1): recurrent = layers.GRU( units=rnn_units, activation=\"tanh\", recurrent_activation=\"sigmoid\", use_bias=True, return_sequences=True, reset_after=True, name=f\"gru_{i}\", ) x = layers.Bidirectional( recurrent, name=f\"bidirectional_{i}\", merge_mode=\"concat\" )(x) if i < rnn_layers: x = layers.Dropout(rate=0.5)(x) # Dense layer x = layers.Dense(units=rnn_units * 2, name=\"dense_1\")(x) x = layers.ReLU(name=\"dense_1_relu\")(x) x = layers.Dropout(rate=0.5)(x) # Classification layer output = layers.Dense(units=output_dim + 1, activation=\"softmax\")(x) # Model model = keras.Model(input_spectrogram, output, name=\"DeepSpeech_2\") # Optimizer opt = keras.optimizers.Adam(learning_rate=1e-4) # Compile the model and return model.compile(optimizer=opt, loss=CTCLoss) return model # Get the model model = build_model( input_dim=fft_length // 2 + 1, output_dim=char_to_num.vocabulary_size(), rnn_units=512, ) model.summary(line_length=110) Model: \"DeepSpeech_2\" ______________________________________________________________________________________________________________ Layer (type) Output Shape Param # ============================================================================================================== input (InputLayer) [(None, None, 193)] 0 ______________________________________________________________________________________________________________ expand_dim (Reshape) (None, None, 193, 1) 0 ______________________________________________________________________________________________________________ conv_1 (Conv2D) (None, None, 97, 32) 14432 ______________________________________________________________________________________________________________ conv_1_bn (BatchNormalization) (None, None, 97, 32) 128 ______________________________________________________________________________________________________________ conv_1_relu (ReLU) (None, None, 97, 32) 0 ______________________________________________________________________________________________________________ conv_2 (Conv2D) (None, None, 49, 32) 236544 ______________________________________________________________________________________________________________ conv_2_bn (BatchNormalization) (None, None, 49, 32) 128 ______________________________________________________________________________________________________________ conv_2_relu (ReLU) (None, None, 49, 32) 0 ______________________________________________________________________________________________________________ reshape (Reshape) (None, None, 1568) 0 ______________________________________________________________________________________________________________ bidirectional_1 (Bidirectional) (None, None, 1024) 6395904 ______________________________________________________________________________________________________________ dropout (Dropout) (None, None, 1024) 0 ______________________________________________________________________________________________________________ bidirectional_2 (Bidirectional) (None, None, 1024) 4724736 ______________________________________________________________________________________________________________ dropout_1 (Dropout) (None, None, 1024) 0 ______________________________________________________________________________________________________________ bidirectional_3 (Bidirectional) (None, None, 1024) 4724736 ______________________________________________________________________________________________________________ dropout_2 (Dropout) (None, None, 1024) 0 ______________________________________________________________________________________________________________ bidirectional_4 (Bidirectional) (None, None, 1024) 4724736 ______________________________________________________________________________________________________________ dropout_3 (Dropout) (None, None, 1024) 0 ______________________________________________________________________________________________________________ bidirectional_5 (Bidirectional) (None, None, 1024) 4724736 ______________________________________________________________________________________________________________ dense_1 (Dense) (None, None, 1024) 1049600 ______________________________________________________________________________________________________________ dense_1_relu (ReLU) (None, None, 1024) 0 ______________________________________________________________________________________________________________ dropout_4 (Dropout) (None, None, 1024) 0 ______________________________________________________________________________________________________________ dense (Dense) (None, None, 32) 32800 ============================================================================================================== Total params: 26,628,480 Trainable params: 26,628,352 Non-trainable params: 128 ______________________________________________________________________________________________________________ Training and Evaluating # A utility function to decode the output of the network def decode_batch_predictions(pred): input_len = np.ones(pred.shape[0]) * pred.shape[1] # Use greedy search. For complex tasks, you can use beam search results = keras.backend.ctc_decode(pred, input_length=input_len, greedy=True)[0][0] # Iterate over the results and get back the text output_text = [] for result in results: result = tf.strings.reduce_join(num_to_char(result)).numpy().decode(\"utf-8\") output_text.append(result) return output_text # A callback class to output a few transcriptions during training class CallbackEval(keras.callbacks.Callback): \"\"\"Displays a batch of outputs after every epoch.\"\"\" def __init__(self, dataset): super().__init__() self.dataset = dataset def on_epoch_end(self, epoch: int, logs=None): predictions = [] targets = [] for batch in self.dataset: X, y = batch batch_predictions = model.predict(X) batch_predictions = decode_batch_predictions(batch_predictions) predictions.extend(batch_predictions) for label in y: label = ( tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\") ) targets.append(label) wer_score = wer(targets, predictions) print(\"-\" * 100) print(f\"Word Error Rate: {wer_score:.4f}\") print(\"-\" * 100) for i in np.random.randint(0, len(predictions), 2): print(f\"Target : {targets[i]}\") print(f\"Prediction: {predictions[i]}\") print(\"-\" * 100) Let's start the training process. # Define the number of epochs. epochs = 1 # Callback function to check transcription on the val set. validation_callback = CallbackEval(validation_dataset) # Train the model history = model.fit( train_dataset, validation_data=validation_dataset, epochs=epochs, callbacks=[validation_callback], ) 2021-09-28 21:16:48.067448: I tensorflow/stream_executor/cuda/cuda_dnn.cc:369] Loaded cuDNN version 8100 369/369 [==============================] - 586s 2s/step - loss: 300.4624 - val_loss: 296.1459 ---------------------------------------------------------------------------------------------------- Word Error Rate: 0.9998 ---------------------------------------------------------------------------------------------------- Target : the procession traversed ratcliffe twice halting for a quarter of an hour in front of the victims' dwelling Prediction: s ---------------------------------------------------------------------------------------------------- Target : some difficulty then arose as to gaining admission to the strong room and it was arranged that a man may another custom house clerk Prediction: s ---------------------------------------------------------------------------------------------------- Inference # Let's check results on more validation samples predictions = [] targets = [] for batch in validation_dataset: X, y = batch batch_predictions = model.predict(X) batch_predictions = decode_batch_predictions(batch_predictions) predictions.extend(batch_predictions) for label in y: label = tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\") targets.append(label) wer_score = wer(targets, predictions) print(\"-\" * 100) print(f\"Word Error Rate: {wer_score:.4f}\") print(\"-\" * 100) for i in np.random.randint(0, len(predictions), 5): print(f\"Target : {targets[i]}\") print(f\"Prediction: {predictions[i]}\") print(\"-\" * 100) ---------------------------------------------------------------------------------------------------- Word Error Rate: 0.9998 ---------------------------------------------------------------------------------------------------- Target : two of the nine agents returned to their rooms the seven others proceeded to an establishment called the cellar coffee house Prediction: ---------------------------------------------------------------------------------------------------- Target : a scaffold was erected in front of that prison for the execution of several convicts named by the recorder Prediction: sss ---------------------------------------------------------------------------------------------------- Target : it was perpetrated upon a respectable country solicitor Prediction: ss ---------------------------------------------------------------------------------------------------- Target : oswald like all marine recruits received training on the rifle range at distances up to five hundred yards Prediction: ---------------------------------------------------------------------------------------------------- Target : chief rowley testified that agents on duty in such a situation usually stay within the building during their relief Prediction: s ---------------------------------------------------------------------------------------------------- Conclusion In practice, you should train for around 50 epochs or more. Each epoch takes approximately 5-6mn using a GeForce RTX 2080 Ti GPU. The model we trained at 50 epochs has a Word Error Rate (WER) ≈ 16% to 17%. Some of the transcriptions around epoch 50: Audio file: LJ017-0009.wav - Target : sir thomas overbury was undoubtedly poisoned by lord rochester in the reign of james the first - Prediction: cer thomas overbery was undoubtedly poisoned by lordrochester in the reign of james the first Audio file: LJ003-0340.wav - Target : the committee does not seem to have yet understood that newgate could be only and properly replaced - Prediction: the committee does not seem to have yet understood that newgate could be only and proberly replace Audio file: LJ011-0136.wav - Target : still no sentence of death was carried out for the offense and in eighteen thirtytwo - Prediction: still no sentence of death was carried out for the offense and in eighteen thirtytwo Training a sequence-to-sequence Transformer for automatic speech recognition. Introduction Automatic speech recognition (ASR) consists of transcribing audio speech segments into text. ASR can be treated as a sequence-to-sequence problem, where the audio can be represented as a sequence of feature vectors and the text as a sequence of characters, words, or subword tokens. For this demonstration, we will use the LJSpeech dataset from the LibriVox project. It consists of short audio clips of a single speaker reading passages from 7 non-fiction books. Our model will be similar to the original Transformer (both encoder and decoder) as proposed in the paper, \"Attention is All You Need\". References: Attention is All You Need Very Deep Self-Attention Networks for End-to-End Speech Recognition Speech Transformers LJSpeech Dataset import os import random from glob import glob import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Define the Transformer Input Layer When processing past target tokens for the decoder, we compute the sum of position embeddings and token embeddings. When processing audio features, we apply convolutional layers to downsample them (via convolution stides) and process local relationships. class TokenEmbedding(layers.Layer): def __init__(self, num_vocab=1000, maxlen=100, num_hid=64): super().__init__() self.emb = tf.keras.layers.Embedding(num_vocab, num_hid) self.pos_emb = layers.Embedding(input_dim=maxlen, output_dim=num_hid) def call(self, x): maxlen = tf.shape(x)[-1] x = self.emb(x) positions = tf.range(start=0, limit=maxlen, delta=1) positions = self.pos_emb(positions) return x + positions class SpeechFeatureEmbedding(layers.Layer): def __init__(self, num_hid=64, maxlen=100): super().__init__() self.conv1 = tf.keras.layers.Conv1D( num_hid, 11, strides=2, padding=\"same\", activation=\"relu\" ) self.conv2 = tf.keras.layers.Conv1D( num_hid, 11, strides=2, padding=\"same\", activation=\"relu\" ) self.conv3 = tf.keras.layers.Conv1D( num_hid, 11, strides=2, padding=\"same\", activation=\"relu\" ) self.pos_emb = layers.Embedding(input_dim=maxlen, output_dim=num_hid) def call(self, x): x = self.conv1(x) x = self.conv2(x) return self.conv3(x) Transformer Encoder Layer class TransformerEncoder(layers.Layer): def __init__(self, embed_dim, num_heads, feed_forward_dim, rate=0.1): super().__init__() self.att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim) self.ffn = keras.Sequential( [ layers.Dense(feed_forward_dim, activation=\"relu\"), layers.Dense(embed_dim), ] ) self.layernorm1 = layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = layers.LayerNormalization(epsilon=1e-6) self.dropout1 = layers.Dropout(rate) self.dropout2 = layers.Dropout(rate) def call(self, inputs, training): attn_output = self.att(inputs, inputs) attn_output = self.dropout1(attn_output, training=training) out1 = self.layernorm1(inputs + attn_output) ffn_output = self.ffn(out1) ffn_output = self.dropout2(ffn_output, training=training) return self.layernorm2(out1 + ffn_output) Transformer Decoder Layer class TransformerDecoder(layers.Layer): def __init__(self, embed_dim, num_heads, feed_forward_dim, dropout_rate=0.1): super().__init__() self.layernorm1 = layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = layers.LayerNormalization(epsilon=1e-6) self.layernorm3 = layers.LayerNormalization(epsilon=1e-6) self.self_att = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim ) self.enc_att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim) self.self_dropout = layers.Dropout(0.5) self.enc_dropout = layers.Dropout(0.1) self.ffn_dropout = layers.Dropout(0.1) self.ffn = keras.Sequential( [ layers.Dense(feed_forward_dim, activation=\"relu\"), layers.Dense(embed_dim), ] ) def causal_attention_mask(self, batch_size, n_dest, n_src, dtype): \"\"\"Masks the upper half of the dot product matrix in self attention. This prevents flow of information from future tokens to current token. 1's in the lower triangle, counting from the lower right corner. \"\"\" i = tf.range(n_dest)[:, None] j = tf.range(n_src) m = i >= j - n_src + n_dest mask = tf.cast(m, dtype) mask = tf.reshape(mask, [1, n_dest, n_src]) mult = tf.concat( [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)], 0 ) return tf.tile(mask, mult) def call(self, enc_out, target): input_shape = tf.shape(target) batch_size = input_shape[0] seq_len = input_shape[1] causal_mask = self.causal_attention_mask(batch_size, seq_len, seq_len, tf.bool) target_att = self.self_att(target, target, attention_mask=causal_mask) target_norm = self.layernorm1(target + self.self_dropout(target_att)) enc_out = self.enc_att(target_norm, enc_out) enc_out_norm = self.layernorm2(self.enc_dropout(enc_out) + target_norm) ffn_out = self.ffn(enc_out_norm) ffn_out_norm = self.layernorm3(enc_out_norm + self.ffn_dropout(ffn_out)) return ffn_out_norm Complete the Transformer model Our model takes audio spectrograms as inputs and predicts a sequence of characters. During training, we give the decoder the target character sequence shifted to the left as input. During inference, the decoder uses its own past predictions to predict the next token. class Transformer(keras.Model): def __init__( self, num_hid=64, num_head=2, num_feed_forward=128, source_maxlen=100, target_maxlen=100, num_layers_enc=4, num_layers_dec=1, num_classes=10, ): super().__init__() self.loss_metric = keras.metrics.Mean(name=\"loss\") self.num_layers_enc = num_layers_enc self.num_layers_dec = num_layers_dec self.target_maxlen = target_maxlen self.num_classes = num_classes self.enc_input = SpeechFeatureEmbedding(num_hid=num_hid, maxlen=source_maxlen) self.dec_input = TokenEmbedding( num_vocab=num_classes, maxlen=target_maxlen, num_hid=num_hid ) self.encoder = keras.Sequential( [self.enc_input] + [ TransformerEncoder(num_hid, num_head, num_feed_forward) for _ in range(num_layers_enc) ] ) for i in range(num_layers_dec): setattr( self, f\"dec_layer_{i}\", TransformerDecoder(num_hid, num_head, num_feed_forward), ) self.classifier = layers.Dense(num_classes) def decode(self, enc_out, target): y = self.dec_input(target) for i in range(self.num_layers_dec): y = getattr(self, f\"dec_layer_{i}\")(enc_out, y) return y def call(self, inputs): source = inputs[0] target = inputs[1] x = self.encoder(source) y = self.decode(x, target) return self.classifier(y) @property def metrics(self): return [self.loss_metric] def train_step(self, batch): \"\"\"Processes one batch inside model.fit().\"\"\" source = batch[\"source\"] target = batch[\"target\"] dec_input = target[:, :-1] dec_target = target[:, 1:] with tf.GradientTape() as tape: preds = self([source, dec_input]) one_hot = tf.one_hot(dec_target, depth=self.num_classes) mask = tf.math.logical_not(tf.math.equal(dec_target, 0)) loss = self.compiled_loss(one_hot, preds, sample_weight=mask) trainable_vars = self.trainable_variables gradients = tape.gradient(loss, trainable_vars) self.optimizer.apply_gradients(zip(gradients, trainable_vars)) self.loss_metric.update_state(loss) return {\"loss\": self.loss_metric.result()} def test_step(self, batch): source = batch[\"source\"] target = batch[\"target\"] dec_input = target[:, :-1] dec_target = target[:, 1:] preds = self([source, dec_input]) one_hot = tf.one_hot(dec_target, depth=self.num_classes) mask = tf.math.logical_not(tf.math.equal(dec_target, 0)) loss = self.compiled_loss(one_hot, preds, sample_weight=mask) self.loss_metric.update_state(loss) return {\"loss\": self.loss_metric.result()} def generate(self, source, target_start_token_idx): \"\"\"Performs inference over one batch of inputs using greedy decoding.\"\"\" bs = tf.shape(source)[0] enc = self.encoder(source) dec_input = tf.ones((bs, 1), dtype=tf.int32) * target_start_token_idx dec_logits = [] for i in range(self.target_maxlen - 1): dec_out = self.decode(enc, dec_input) logits = self.classifier(dec_out) logits = tf.argmax(logits, axis=-1, output_type=tf.int32) last_logit = tf.expand_dims(logits[:, -1], axis=-1) dec_logits.append(last_logit) dec_input = tf.concat([dec_input, last_logit], axis=-1) return dec_input Download the dataset Note: This requires ~3.6 GB of disk space and takes ~5 minutes for the extraction of files. keras.utils.get_file( os.path.join(os.getcwd(), \"data.tar.gz\"), \"https://data.keithito.com/data/speech/LJSpeech-1.1.tar.bz2\", extract=True, archive_format=\"tar\", cache_dir=\".\", ) saveto = \"./datasets/LJSpeech-1.1\" wavs = glob(\"{}/**/*.wav\".format(saveto), recursive=True) id_to_text = {} with open(os.path.join(saveto, \"metadata.csv\"), encoding=\"utf-8\") as f: for line in f: id = line.strip().split(\"|\")[0] text = line.strip().split(\"|\")[2] id_to_text[id] = text def get_data(wavs, id_to_text, maxlen=50): \"\"\" returns mapping of audio paths and transcription texts \"\"\" data = [] for w in wavs: id = w.split(\"/\")[-1].split(\".\")[0] if len(id_to_text[id]) < maxlen: data.append({\"audio\": w, \"text\": id_to_text[id]}) return data Downloading data from https://data.keithito.com/data/speech/LJSpeech-1.1.tar.bz2 2748579840/2748572632 [==============================] - 57s 0us/step Preprocess the dataset class VectorizeChar: def __init__(self, max_len=50): self.vocab = ( [\"-\", \"#\", \"<\", \">\"] + [chr(i + 96) for i in range(1, 27)] + [\" \", \".\", \",\", \"?\"] ) self.max_len = max_len self.char_to_idx = {} for i, ch in enumerate(self.vocab): self.char_to_idx[ch] = i def __call__(self, text): text = text.lower() text = text[: self.max_len - 2] text = \"<\" + text + \">\" pad_len = self.max_len - len(text) return [self.char_to_idx.get(ch, 1) for ch in text] + [0] * pad_len def get_vocabulary(self): return self.vocab max_target_len = 200 # all transcripts in out data are < 200 characters data = get_data(wavs, id_to_text, max_target_len) vectorizer = VectorizeChar(max_target_len) print(\"vocab size\", len(vectorizer.get_vocabulary())) def create_text_ds(data): texts = [_[\"text\"] for _ in data] text_ds = [vectorizer(t) for t in texts] text_ds = tf.data.Dataset.from_tensor_slices(text_ds) return text_ds def path_to_audio(path): # spectrogram using stft audio = tf.io.read_file(path) audio, _ = tf.audio.decode_wav(audio, 1) audio = tf.squeeze(audio, axis=-1) stfts = tf.signal.stft(audio, frame_length=200, frame_step=80, fft_length=256) x = tf.math.pow(tf.abs(stfts), 0.5) # normalisation means = tf.math.reduce_mean(x, 1, keepdims=True) stddevs = tf.math.reduce_std(x, 1, keepdims=True) x = (x - means) / stddevs audio_len = tf.shape(x)[0] # padding to 10 seconds pad_len = 2754 paddings = tf.constant([[0, pad_len], [0, 0]]) x = tf.pad(x, paddings, \"CONSTANT\")[:pad_len, :] return x def create_audio_ds(data): flist = [_[\"audio\"] for _ in data] audio_ds = tf.data.Dataset.from_tensor_slices(flist) audio_ds = audio_ds.map( path_to_audio, num_parallel_calls=tf.data.AUTOTUNE ) return audio_ds def create_tf_dataset(data, bs=4): audio_ds = create_audio_ds(data) text_ds = create_text_ds(data) ds = tf.data.Dataset.zip((audio_ds, text_ds)) ds = ds.map(lambda x, y: {\"source\": x, \"target\": y}) ds = ds.batch(bs) ds = ds.prefetch(tf.data.AUTOTUNE) return ds split = int(len(data) * 0.99) train_data = data[:split] test_data = data[split:] ds = create_tf_dataset(train_data, bs=64) val_ds = create_tf_dataset(test_data, bs=4) vocab size 34 Callbacks to display predictions class DisplayOutputs(keras.callbacks.Callback): def __init__( self, batch, idx_to_token, target_start_token_idx=27, target_end_token_idx=28 ): \"\"\"Displays a batch of outputs after every epoch Args: batch: A test batch containing the keys \"source\" and \"target\" idx_to_token: A List containing the vocabulary tokens corresponding to their indices target_start_token_idx: A start token index in the target vocabulary target_end_token_idx: An end token index in the target vocabulary \"\"\" self.batch = batch self.target_start_token_idx = target_start_token_idx self.target_end_token_idx = target_end_token_idx self.idx_to_char = idx_to_token def on_epoch_end(self, epoch, logs=None): if epoch % 5 != 0: return source = self.batch[\"source\"] target = self.batch[\"target\"].numpy() bs = tf.shape(source)[0] preds = self.model.generate(source, self.target_start_token_idx) preds = preds.numpy() for i in range(bs): target_text = \"\".join([self.idx_to_char[_] for _ in target[i, :]]) prediction = \"\" for idx in preds[i, :]: prediction += self.idx_to_char[idx] if idx == self.target_end_token_idx: break print(f\"target: {target_text.replace('-','')}\") print(f\"prediction: {prediction}\n\") Learning rate schedule class CustomSchedule(keras.optimizers.schedules.LearningRateSchedule): def __init__( self, init_lr=0.00001, lr_after_warmup=0.001, final_lr=0.00001, warmup_epochs=15, decay_epochs=85, steps_per_epoch=203, ): super().__init__() self.init_lr = init_lr self.lr_after_warmup = lr_after_warmup self.final_lr = final_lr self.warmup_epochs = warmup_epochs self.decay_epochs = decay_epochs self.steps_per_epoch = steps_per_epoch def calculate_lr(self, epoch): \"\"\" linear warm up - linear decay \"\"\" warmup_lr = ( self.init_lr + ((self.lr_after_warmup - self.init_lr) / (self.warmup_epochs - 1)) * epoch ) decay_lr = tf.math.maximum( self.final_lr, self.lr_after_warmup - (epoch - self.warmup_epochs) * (self.lr_after_warmup - self.final_lr) / (self.decay_epochs), ) return tf.math.minimum(warmup_lr, decay_lr) def __call__(self, step): epoch = step // self.steps_per_epoch return self.calculate_lr(epoch) Create & train the end-to-end model batch = next(iter(val_ds)) # The vocabulary to convert predicted indices into characters idx_to_char = vectorizer.get_vocabulary() display_cb = DisplayOutputs( batch, idx_to_char, target_start_token_idx=2, target_end_token_idx=3 ) # set the arguments as per vocabulary index for '<' and '>' model = Transformer( num_hid=200, num_head=2, num_feed_forward=400, target_maxlen=max_target_len, num_layers_enc=4, num_layers_dec=1, num_classes=34, ) loss_fn = tf.keras.losses.CategoricalCrossentropy( from_logits=True, label_smoothing=0.1, ) learning_rate = CustomSchedule( init_lr=0.00001, lr_after_warmup=0.001, final_lr=0.00001, warmup_epochs=15, decay_epochs=85, steps_per_epoch=len(ds), ) optimizer = keras.optimizers.Adam(learning_rate) model.compile(optimizer=optimizer, loss=loss_fn) history = model.fit(ds, validation_data=val_ds, callbacks=[display_cb], epochs=1) 203/203 [==============================] - 349s 2s/step - loss: 1.7437 - val_loss: 1.4650 target: prediction: prediction: prediction: prediction: prediction: target: prediction: Inversion of audio from mel-spectograms using the MelGAN architecture and feature matching. Introduction Autoregressive vocoders have been ubiquitous for a majority of the history of speech processing, but for most of their existence they have lacked parallelism. MelGAN is a non-autoregressive, fully convolutional vocoder architecture used for purposes ranging from spectral inversion and speech enhancement to present-day state-of-the-art speech synthesis when used as a decoder with models like Tacotron2 or FastSpeech that convert text to mel spectrograms. In this tutorial, we will have a look at the MelGAN architecture and how it can achieve fast spectral inversion, i.e. conversion of spectrograms to audio waves. The MelGAN implemented in this tutorial is similar to the original implementation with only the difference of method of padding for convolutions where we will use 'same' instead of reflect padding. Importing and Defining Hyperparameters !pip install -qqq tensorflow_addons !pip install -qqq tensorflow-io import tensorflow as tf import tensorflow_io as tfio from tensorflow import keras from tensorflow.keras import layers from tensorflow_addons import layers as addon_layers # Setting logger level to avoid input shape warnings tf.get_logger().setLevel(\"ERROR\") # Defining hyperparameters DESIRED_SAMPLES = 8192 LEARNING_RATE_GEN = 1e-5 LEARNING_RATE_DISC = 1e-6 BATCH_SIZE = 16 mse = keras.losses.MeanSquaredError() mae = keras.losses.MeanAbsoluteError() |████████████████████████████████| 1.1 MB 5.1 MB/s |████████████████████████████████| 22.7 MB 1.7 MB/s |████████████████████████████████| 2.1 MB 36.2 MB/s Loading the Dataset This example uses the LJSpeech dataset. The LJSpeech dataset is primarily used for text-to-speech and consists of 13,100 discrete speech samples taken from 7 non-fiction books, having a total length of approximately 24 hours. The MelGAN training is only concerned with the audio waves so we process only the WAV files and ignore the audio annotations. !wget https://data.keithito.com/data/speech/LJSpeech-1.1.tar.bz2 !tar -xf /content/LJSpeech-1.1.tar.bz2 --2021-09-16 11:45:24-- https://data.keithito.com/data/speech/LJSpeech-1.1.tar.bz2 Resolving data.keithito.com (data.keithito.com)... 174.138.79.61 Connecting to data.keithito.com (data.keithito.com)|174.138.79.61|:443... connected. HTTP request sent, awaiting response... 200 OK Length: 2748572632 (2.6G) [application/octet-stream] Saving to: ‘LJSpeech-1.1.tar.bz2’ LJSpeech-1.1.tar.bz 100%[===================>] 2.56G 68.3MB/s in 36s 2021-09-16 11:46:01 (72.2 MB/s) - ‘LJSpeech-1.1.tar.bz2’ saved [2748572632/2748572632] We create a tf.data.Dataset to load and process the audio files on the fly. The preprocess() function takes the file path as input and returns two instances of the wave, one for input and one as the ground truth for comparsion. The input wave will be mapped to a spectrogram using the custom MelSpec layer as shown later in this example. # Splitting the dataset into training and testing splits wavs = tf.io.gfile.glob(\"LJSpeech-1.1/wavs/*.wav\") print(f\"Number of audio files: {len(wavs)}\") # Mapper function for loading the audio. This function returns two instances of the wave def preprocess(filename): audio = tf.audio.decode_wav(tf.io.read_file(filename), 1, DESIRED_SAMPLES).audio return audio, audio # Create tf.data.Dataset objects and apply preprocessing train_dataset = tf.data.Dataset.from_tensor_slices((wavs,)) train_dataset = train_dataset.map(preprocess, num_parallel_calls=tf.data.AUTOTUNE) Number of audio files: 13100 Defining custom layers for MelGAN The MelGAN architecture consists of 3 main modules: The residual block Dilated convolutional block Discriminator block MelGAN Since the network takes a mel-spectrogram as input, we will create an additional custom layer which can convert the raw audio wave to a spectrogram on-the-fly. We use the raw audio tensor from train_dataset and map it to a mel-spectrogram using the MelSpec layer below. # Custom keras layer for on-the-fly audio to spectrogram conversion class MelSpec(layers.Layer): def __init__( self, frame_length=1024, frame_step=256, fft_length=None, sampling_rate=22050, num_mel_channels=80, freq_min=125, freq_max=7600, **kwargs, ): super().__init__(**kwargs) self.frame_length = frame_length self.frame_step = frame_step self.fft_length = fft_length self.sampling_rate = sampling_rate self.num_mel_channels = num_mel_channels self.freq_min = freq_min self.freq_max = freq_max # Defining mel filter. This filter will be multiplied with the STFT output self.mel_filterbank = tf.signal.linear_to_mel_weight_matrix( num_mel_bins=self.num_mel_channels, num_spectrogram_bins=self.frame_length // 2 + 1, sample_rate=self.sampling_rate, lower_edge_hertz=self.freq_min, upper_edge_hertz=self.freq_max, ) def call(self, audio, training=True): # We will only perform the transformation during training. if training: # Taking the Short Time Fourier Transform. Ensure that the audio is padded. # In the paper, the STFT output is padded using the 'REFLECT' strategy. stft = tf.signal.stft( tf.squeeze(audio, -1), self.frame_length, self.frame_step, self.fft_length, pad_end=True, ) # Taking the magnitude of the STFT output magnitude = tf.abs(stft) # Multiplying the Mel-filterbank with the magnitude and scaling it using the db scale mel = tf.matmul(tf.square(magnitude), self.mel_filterbank) log_mel_spec = tfio.audio.dbscale(mel, top_db=80) return log_mel_spec else: return audio def get_config(self): config = super(MelSpec, self).get_config() config.update( { \"frame_length\": self.frame_length, \"frame_step\": self.frame_step, \"fft_length\": self.fft_length, \"sampling_rate\": self.sampling_rate, \"num_mel_channels\": self.num_mel_channels, \"freq_min\": self.freq_min, \"freq_max\": self.freq_max, } ) return config The residual convolutional block extensively uses dilations and has a total receptive field of 27 timesteps per block. The dilations must grow as a power of the kernel_size to ensure reduction of hissing noise in the output. The network proposed by the paper is as follows: ConvBlock # Creating the residual stack block def residual_stack(input, filters): \"\"\"Convolutional residual stack with weight normalization. Args: filter: int, determines filter size for the residual stack. Returns: Residual stack output. \"\"\" c1 = addon_layers.WeightNormalization( layers.Conv1D(filters, 3, dilation_rate=1, padding=\"same\"), data_init=False )(input) lrelu1 = layers.LeakyReLU()(c1) c2 = addon_layers.WeightNormalization( layers.Conv1D(filters, 3, dilation_rate=1, padding=\"same\"), data_init=False )(lrelu1) add1 = layers.Add()([c2, input]) lrelu2 = layers.LeakyReLU()(add1) c3 = addon_layers.WeightNormalization( layers.Conv1D(filters, 3, dilation_rate=3, padding=\"same\"), data_init=False )(lrelu2) lrelu3 = layers.LeakyReLU()(c3) c4 = addon_layers.WeightNormalization( layers.Conv1D(filters, 3, dilation_rate=1, padding=\"same\"), data_init=False )(lrelu3) add2 = layers.Add()([add1, c4]) lrelu4 = layers.LeakyReLU()(add2) c5 = addon_layers.WeightNormalization( layers.Conv1D(filters, 3, dilation_rate=9, padding=\"same\"), data_init=False )(lrelu4) lrelu5 = layers.LeakyReLU()(c5) c6 = addon_layers.WeightNormalization( layers.Conv1D(filters, 3, dilation_rate=1, padding=\"same\"), data_init=False )(lrelu5) add3 = layers.Add()([c6, add2]) return add3 Each convolutional block uses the dilations offered by the residual stack and upsamples the input data by the upsampling_factor. # Dilated convolutional block consisting of the Residual stack def conv_block(input, conv_dim, upsampling_factor): \"\"\"Dilated Convolutional Block with weight normalization. Args: conv_dim: int, determines filter size for the block. upsampling_factor: int, scale for upsampling. Returns: Dilated convolution block. \"\"\" conv_t = addon_layers.WeightNormalization( layers.Conv1DTranspose(conv_dim, 16, upsampling_factor, padding=\"same\"), data_init=False, )(input) lrelu1 = layers.LeakyReLU()(conv_t) res_stack = residual_stack(lrelu1, conv_dim) lrelu2 = layers.LeakyReLU()(res_stack) return lrelu2 The discriminator block consists of convolutions and downsampling layers. This block is essential for the implementation of the feature matching technique. Each discriminator outputs a list of feature maps that will be compared during training to compute the feature matching loss. def discriminator_block(input): conv1 = addon_layers.WeightNormalization( layers.Conv1D(16, 15, 1, \"same\"), data_init=False )(input) lrelu1 = layers.LeakyReLU()(conv1) conv2 = addon_layers.WeightNormalization( layers.Conv1D(64, 41, 4, \"same\", groups=4), data_init=False )(lrelu1) lrelu2 = layers.LeakyReLU()(conv2) conv3 = addon_layers.WeightNormalization( layers.Conv1D(256, 41, 4, \"same\", groups=16), data_init=False )(lrelu2) lrelu3 = layers.LeakyReLU()(conv3) conv4 = addon_layers.WeightNormalization( layers.Conv1D(1024, 41, 4, \"same\", groups=64), data_init=False )(lrelu3) lrelu4 = layers.LeakyReLU()(conv4) conv5 = addon_layers.WeightNormalization( layers.Conv1D(1024, 41, 4, \"same\", groups=256), data_init=False )(lrelu4) lrelu5 = layers.LeakyReLU()(conv5) conv6 = addon_layers.WeightNormalization( layers.Conv1D(1024, 5, 1, \"same\"), data_init=False )(lrelu5) lrelu6 = layers.LeakyReLU()(conv6) conv7 = addon_layers.WeightNormalization( layers.Conv1D(1, 3, 1, \"same\"), data_init=False )(lrelu6) return [lrelu1, lrelu2, lrelu3, lrelu4, lrelu5, lrelu6, conv7] Create the generator def create_generator(input_shape): inp = keras.Input(input_shape) x = MelSpec()(inp) x = layers.Conv1D(512, 7, padding=\"same\")(x) x = layers.LeakyReLU()(x) x = conv_block(x, 256, 8) x = conv_block(x, 128, 8) x = conv_block(x, 64, 2) x = conv_block(x, 32, 2) x = addon_layers.WeightNormalization( layers.Conv1D(1, 7, padding=\"same\", activation=\"tanh\") )(x) return keras.Model(inp, x) # We use a dynamic input shape for the generator since the model is fully convolutional generator = create_generator((None, 1)) generator.summary() Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, None, 1)] 0 __________________________________________________________________________________________________ mel_spec (MelSpec) (None, None, 80) 0 input_1[0][0] __________________________________________________________________________________________________ conv1d (Conv1D) (None, None, 512) 287232 mel_spec[0][0] __________________________________________________________________________________________________ leaky_re_lu (LeakyReLU) (None, None, 512) 0 conv1d[0][0] __________________________________________________________________________________________________ weight_normalization (WeightNor (None, None, 256) 2097921 leaky_re_lu[0][0] __________________________________________________________________________________________________ leaky_re_lu_1 (LeakyReLU) (None, None, 256) 0 weight_normalization[0][0] __________________________________________________________________________________________________ weight_normalization_1 (WeightN (None, None, 256) 197121 leaky_re_lu_1[0][0] __________________________________________________________________________________________________ leaky_re_lu_2 (LeakyReLU) (None, None, 256) 0 weight_normalization_1[0][0] __________________________________________________________________________________________________ weight_normalization_2 (WeightN (None, None, 256) 197121 leaky_re_lu_2[0][0] __________________________________________________________________________________________________ add (Add) (None, None, 256) 0 weight_normalization_2[0][0] leaky_re_lu_1[0][0] __________________________________________________________________________________________________ leaky_re_lu_3 (LeakyReLU) (None, None, 256) 0 add[0][0] __________________________________________________________________________________________________ weight_normalization_3 (WeightN (None, None, 256) 197121 leaky_re_lu_3[0][0] __________________________________________________________________________________________________ leaky_re_lu_4 (LeakyReLU) (None, None, 256) 0 weight_normalization_3[0][0] __________________________________________________________________________________________________ weight_normalization_4 (WeightN (None, None, 256) 197121 leaky_re_lu_4[0][0] __________________________________________________________________________________________________ add_1 (Add) (None, None, 256) 0 add[0][0] weight_normalization_4[0][0] __________________________________________________________________________________________________ leaky_re_lu_5 (LeakyReLU) (None, None, 256) 0 add_1[0][0] __________________________________________________________________________________________________ weight_normalization_5 (WeightN (None, None, 256) 197121 leaky_re_lu_5[0][0] __________________________________________________________________________________________________ leaky_re_lu_6 (LeakyReLU) (None, None, 256) 0 weight_normalization_5[0][0] __________________________________________________________________________________________________ weight_normalization_6 (WeightN (None, None, 256) 197121 leaky_re_lu_6[0][0] __________________________________________________________________________________________________ add_2 (Add) (None, None, 256) 0 weight_normalization_6[0][0] add_1[0][0] __________________________________________________________________________________________________ leaky_re_lu_7 (LeakyReLU) (None, None, 256) 0 add_2[0][0] __________________________________________________________________________________________________ weight_normalization_7 (WeightN (None, None, 128) 524673 leaky_re_lu_7[0][0] __________________________________________________________________________________________________ leaky_re_lu_8 (LeakyReLU) (None, None, 128) 0 weight_normalization_7[0][0] __________________________________________________________________________________________________ weight_normalization_8 (WeightN (None, None, 128) 49409 leaky_re_lu_8[0][0] __________________________________________________________________________________________________ leaky_re_lu_9 (LeakyReLU) (None, None, 128) 0 weight_normalization_8[0][0] __________________________________________________________________________________________________ weight_normalization_9 (WeightN (None, None, 128) 49409 leaky_re_lu_9[0][0] __________________________________________________________________________________________________ add_3 (Add) (None, None, 128) 0 weight_normalization_9[0][0] leaky_re_lu_8[0][0] __________________________________________________________________________________________________ leaky_re_lu_10 (LeakyReLU) (None, None, 128) 0 add_3[0][0] __________________________________________________________________________________________________ weight_normalization_10 (Weight (None, None, 128) 49409 leaky_re_lu_10[0][0] __________________________________________________________________________________________________ leaky_re_lu_11 (LeakyReLU) (None, None, 128) 0 weight_normalization_10[0][0] __________________________________________________________________________________________________ weight_normalization_11 (Weight (None, None, 128) 49409 leaky_re_lu_11[0][0] __________________________________________________________________________________________________ add_4 (Add) (None, None, 128) 0 add_3[0][0] weight_normalization_11[0][0] __________________________________________________________________________________________________ leaky_re_lu_12 (LeakyReLU) (None, None, 128) 0 add_4[0][0] __________________________________________________________________________________________________ weight_normalization_12 (Weight (None, None, 128) 49409 leaky_re_lu_12[0][0] __________________________________________________________________________________________________ leaky_re_lu_13 (LeakyReLU) (None, None, 128) 0 weight_normalization_12[0][0] __________________________________________________________________________________________________ weight_normalization_13 (Weight (None, None, 128) 49409 leaky_re_lu_13[0][0] __________________________________________________________________________________________________ add_5 (Add) (None, None, 128) 0 weight_normalization_13[0][0] add_4[0][0] __________________________________________________________________________________________________ leaky_re_lu_14 (LeakyReLU) (None, None, 128) 0 add_5[0][0] __________________________________________________________________________________________________ weight_normalization_14 (Weight (None, None, 64) 131265 leaky_re_lu_14[0][0] __________________________________________________________________________________________________ leaky_re_lu_15 (LeakyReLU) (None, None, 64) 0 weight_normalization_14[0][0] __________________________________________________________________________________________________ weight_normalization_15 (Weight (None, None, 64) 12417 leaky_re_lu_15[0][0] __________________________________________________________________________________________________ leaky_re_lu_16 (LeakyReLU) (None, None, 64) 0 weight_normalization_15[0][0] __________________________________________________________________________________________________ weight_normalization_16 (Weight (None, None, 64) 12417 leaky_re_lu_16[0][0] __________________________________________________________________________________________________ add_6 (Add) (None, None, 64) 0 weight_normalization_16[0][0] leaky_re_lu_15[0][0] __________________________________________________________________________________________________ leaky_re_lu_17 (LeakyReLU) (None, None, 64) 0 add_6[0][0] __________________________________________________________________________________________________ weight_normalization_17 (Weight (None, None, 64) 12417 leaky_re_lu_17[0][0] __________________________________________________________________________________________________ leaky_re_lu_18 (LeakyReLU) (None, None, 64) 0 weight_normalization_17[0][0] __________________________________________________________________________________________________ weight_normalization_18 (Weight (None, None, 64) 12417 leaky_re_lu_18[0][0] __________________________________________________________________________________________________ add_7 (Add) (None, None, 64) 0 add_6[0][0] weight_normalization_18[0][0] __________________________________________________________________________________________________ leaky_re_lu_19 (LeakyReLU) (None, None, 64) 0 add_7[0][0] __________________________________________________________________________________________________ weight_normalization_19 (Weight (None, None, 64) 12417 leaky_re_lu_19[0][0] __________________________________________________________________________________________________ leaky_re_lu_20 (LeakyReLU) (None, None, 64) 0 weight_normalization_19[0][0] __________________________________________________________________________________________________ weight_normalization_20 (Weight (None, None, 64) 12417 leaky_re_lu_20[0][0] __________________________________________________________________________________________________ add_8 (Add) (None, None, 64) 0 weight_normalization_20[0][0] add_7[0][0] __________________________________________________________________________________________________ leaky_re_lu_21 (LeakyReLU) (None, None, 64) 0 add_8[0][0] __________________________________________________________________________________________________ weight_normalization_21 (Weight (None, None, 32) 32865 leaky_re_lu_21[0][0] __________________________________________________________________________________________________ leaky_re_lu_22 (LeakyReLU) (None, None, 32) 0 weight_normalization_21[0][0] __________________________________________________________________________________________________ weight_normalization_22 (Weight (None, None, 32) 3137 leaky_re_lu_22[0][0] __________________________________________________________________________________________________ leaky_re_lu_23 (LeakyReLU) (None, None, 32) 0 weight_normalization_22[0][0] __________________________________________________________________________________________________ weight_normalization_23 (Weight (None, None, 32) 3137 leaky_re_lu_23[0][0] __________________________________________________________________________________________________ add_9 (Add) (None, None, 32) 0 weight_normalization_23[0][0] leaky_re_lu_22[0][0] __________________________________________________________________________________________________ leaky_re_lu_24 (LeakyReLU) (None, None, 32) 0 add_9[0][0] __________________________________________________________________________________________________ weight_normalization_24 (Weight (None, None, 32) 3137 leaky_re_lu_24[0][0] __________________________________________________________________________________________________ leaky_re_lu_25 (LeakyReLU) (None, None, 32) 0 weight_normalization_24[0][0] __________________________________________________________________________________________________ weight_normalization_25 (Weight (None, None, 32) 3137 leaky_re_lu_25[0][0] __________________________________________________________________________________________________ add_10 (Add) (None, None, 32) 0 add_9[0][0] weight_normalization_25[0][0] __________________________________________________________________________________________________ leaky_re_lu_26 (LeakyReLU) (None, None, 32) 0 add_10[0][0] __________________________________________________________________________________________________ weight_normalization_26 (Weight (None, None, 32) 3137 leaky_re_lu_26[0][0] __________________________________________________________________________________________________ leaky_re_lu_27 (LeakyReLU) (None, None, 32) 0 weight_normalization_26[0][0] __________________________________________________________________________________________________ weight_normalization_27 (Weight (None, None, 32) 3137 leaky_re_lu_27[0][0] __________________________________________________________________________________________________ add_11 (Add) (None, None, 32) 0 weight_normalization_27[0][0] add_10[0][0] __________________________________________________________________________________________________ leaky_re_lu_28 (LeakyReLU) (None, None, 32) 0 add_11[0][0] __________________________________________________________________________________________________ weight_normalization_28 (Weight (None, None, 1) 452 leaky_re_lu_28[0][0] ================================================================================================== Total params: 4,646,912 Trainable params: 4,646,658 Non-trainable params: 254 __________________________________________________________________________________________________ Create the discriminator def create_discriminator(input_shape): inp = keras.Input(input_shape) out_map1 = discriminator_block(inp) pool1 = layers.AveragePooling1D()(inp) out_map2 = discriminator_block(pool1) pool2 = layers.AveragePooling1D()(pool1) out_map3 = discriminator_block(pool2) return keras.Model(inp, [out_map1, out_map2, out_map3]) # We use a dynamic input shape for the discriminator # This is done because the input shape for the generator is unknown discriminator = create_discriminator((None, 1)) discriminator.summary() Model: \"model_1\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_2 (InputLayer) [(None, None, 1)] 0 __________________________________________________________________________________________________ average_pooling1d (AveragePooli (None, None, 1) 0 input_2[0][0] __________________________________________________________________________________________________ average_pooling1d_1 (AveragePoo (None, None, 1) 0 average_pooling1d[0][0] __________________________________________________________________________________________________ weight_normalization_29 (Weight (None, None, 16) 273 input_2[0][0] __________________________________________________________________________________________________ weight_normalization_36 (Weight (None, None, 16) 273 average_pooling1d[0][0] __________________________________________________________________________________________________ weight_normalization_43 (Weight (None, None, 16) 273 average_pooling1d_1[0][0] __________________________________________________________________________________________________ leaky_re_lu_29 (LeakyReLU) (None, None, 16) 0 weight_normalization_29[0][0] __________________________________________________________________________________________________ leaky_re_lu_35 (LeakyReLU) (None, None, 16) 0 weight_normalization_36[0][0] __________________________________________________________________________________________________ leaky_re_lu_41 (LeakyReLU) (None, None, 16) 0 weight_normalization_43[0][0] __________________________________________________________________________________________________ weight_normalization_30 (Weight (None, None, 64) 10625 leaky_re_lu_29[0][0] __________________________________________________________________________________________________ weight_normalization_37 (Weight (None, None, 64) 10625 leaky_re_lu_35[0][0] __________________________________________________________________________________________________ weight_normalization_44 (Weight (None, None, 64) 10625 leaky_re_lu_41[0][0] __________________________________________________________________________________________________ leaky_re_lu_30 (LeakyReLU) (None, None, 64) 0 weight_normalization_30[0][0] __________________________________________________________________________________________________ leaky_re_lu_36 (LeakyReLU) (None, None, 64) 0 weight_normalization_37[0][0] __________________________________________________________________________________________________ leaky_re_lu_42 (LeakyReLU) (None, None, 64) 0 weight_normalization_44[0][0] __________________________________________________________________________________________________ weight_normalization_31 (Weight (None, None, 256) 42497 leaky_re_lu_30[0][0] __________________________________________________________________________________________________ weight_normalization_38 (Weight (None, None, 256) 42497 leaky_re_lu_36[0][0] __________________________________________________________________________________________________ weight_normalization_45 (Weight (None, None, 256) 42497 leaky_re_lu_42[0][0] __________________________________________________________________________________________________ leaky_re_lu_31 (LeakyReLU) (None, None, 256) 0 weight_normalization_31[0][0] __________________________________________________________________________________________________ leaky_re_lu_37 (LeakyReLU) (None, None, 256) 0 weight_normalization_38[0][0] __________________________________________________________________________________________________ leaky_re_lu_43 (LeakyReLU) (None, None, 256) 0 weight_normalization_45[0][0] __________________________________________________________________________________________________ weight_normalization_32 (Weight (None, None, 1024) 169985 leaky_re_lu_31[0][0] __________________________________________________________________________________________________ weight_normalization_39 (Weight (None, None, 1024) 169985 leaky_re_lu_37[0][0] __________________________________________________________________________________________________ weight_normalization_46 (Weight (None, None, 1024) 169985 leaky_re_lu_43[0][0] __________________________________________________________________________________________________ leaky_re_lu_32 (LeakyReLU) (None, None, 1024) 0 weight_normalization_32[0][0] __________________________________________________________________________________________________ leaky_re_lu_38 (LeakyReLU) (None, None, 1024) 0 weight_normalization_39[0][0] __________________________________________________________________________________________________ leaky_re_lu_44 (LeakyReLU) (None, None, 1024) 0 weight_normalization_46[0][0] __________________________________________________________________________________________________ weight_normalization_33 (Weight (None, None, 1024) 169985 leaky_re_lu_32[0][0] __________________________________________________________________________________________________ weight_normalization_40 (Weight (None, None, 1024) 169985 leaky_re_lu_38[0][0] __________________________________________________________________________________________________ weight_normalization_47 (Weight (None, None, 1024) 169985 leaky_re_lu_44[0][0] __________________________________________________________________________________________________ leaky_re_lu_33 (LeakyReLU) (None, None, 1024) 0 weight_normalization_33[0][0] __________________________________________________________________________________________________ leaky_re_lu_39 (LeakyReLU) (None, None, 1024) 0 weight_normalization_40[0][0] __________________________________________________________________________________________________ leaky_re_lu_45 (LeakyReLU) (None, None, 1024) 0 weight_normalization_47[0][0] __________________________________________________________________________________________________ weight_normalization_34 (Weight (None, None, 1024) 5244929 leaky_re_lu_33[0][0] __________________________________________________________________________________________________ weight_normalization_41 (Weight (None, None, 1024) 5244929 leaky_re_lu_39[0][0] __________________________________________________________________________________________________ weight_normalization_48 (Weight (None, None, 1024) 5244929 leaky_re_lu_45[0][0] __________________________________________________________________________________________________ leaky_re_lu_34 (LeakyReLU) (None, None, 1024) 0 weight_normalization_34[0][0] __________________________________________________________________________________________________ leaky_re_lu_40 (LeakyReLU) (None, None, 1024) 0 weight_normalization_41[0][0] __________________________________________________________________________________________________ leaky_re_lu_46 (LeakyReLU) (None, None, 1024) 0 weight_normalization_48[0][0] __________________________________________________________________________________________________ weight_normalization_35 (Weight (None, None, 1) 3075 leaky_re_lu_34[0][0] __________________________________________________________________________________________________ weight_normalization_42 (Weight (None, None, 1) 3075 leaky_re_lu_40[0][0] __________________________________________________________________________________________________ weight_normalization_49 (Weight (None, None, 1) 3075 leaky_re_lu_46[0][0] ================================================================================================== Total params: 16,924,107 Trainable params: 16,924,086 Non-trainable params: 21 __________________________________________________________________________________________________ Defining the loss functions Generator Loss The generator architecture uses a combination of two losses Mean Squared Error: This is the standard MSE generator loss calculated between ones and the outputs from the discriminator with N layers. Feature Matching Loss: This loss involves extracting the outputs of every layer from the discriminator for both the generator and ground truth and compare each layer output k using Mean Absolute Error. Discriminator Loss The discriminator uses the Mean Absolute Error and compares the real data predictions with ones and generated predictions with zeros. # Generator loss def generator_loss(real_pred, fake_pred): \"\"\"Loss function for the generator. Args: real_pred: Tensor, output of the ground truth wave passed through the discriminator. fake_pred: Tensor, output of the generator prediction passed through the discriminator. Returns: Loss for the generator. \"\"\" gen_loss = [] for i in range(len(fake_pred)): gen_loss.append(mse(tf.ones_like(fake_pred[i][-1]), fake_pred[i][-1])) return tf.reduce_mean(gen_loss) def feature_matching_loss(real_pred, fake_pred): \"\"\"Implements the feature matching loss. Args: real_pred: Tensor, output of the ground truth wave passed through the discriminator. fake_pred: Tensor, output of the generator prediction passed through the discriminator. Returns: Feature Matching Loss. \"\"\" fm_loss = [] for i in range(len(fake_pred)): for j in range(len(fake_pred[i]) - 1): fm_loss.append(mae(real_pred[i][j], fake_pred[i][j])) return tf.reduce_mean(fm_loss) def discriminator_loss(real_pred, fake_pred): \"\"\"Implements the discriminator loss. Args: real_pred: Tensor, output of the ground truth wave passed through the discriminator. fake_pred: Tensor, output of the generator prediction passed through the discriminator. Returns: Discriminator Loss. \"\"\" real_loss, fake_loss = [], [] for i in range(len(real_pred)): real_loss.append(mse(tf.ones_like(real_pred[i][-1]), real_pred[i][-1])) fake_loss.append(mse(tf.zeros_like(fake_pred[i][-1]), fake_pred[i][-1])) # Calculating the final discriminator loss after scaling disc_loss = tf.reduce_mean(real_loss) + tf.reduce_mean(fake_loss) return disc_loss Defining the MelGAN model for training. This subclass overrides the train_step() method to implement the training logic. class MelGAN(keras.Model): def __init__(self, generator, discriminator, **kwargs): \"\"\"MelGAN trainer class Args: generator: keras.Model, Generator model discriminator: keras.Model, Discriminator model \"\"\" super().__init__(**kwargs) self.generator = generator self.discriminator = discriminator def compile( self, gen_optimizer, disc_optimizer, generator_loss, feature_matching_loss, discriminator_loss, ): \"\"\"MelGAN compile method. Args: gen_optimizer: keras.optimizer, optimizer to be used for training disc_optimizer: keras.optimizer, optimizer to be used for training generator_loss: callable, loss function for generator feature_matching_loss: callable, loss function for feature matching discriminator_loss: callable, loss function for discriminator \"\"\" super().compile() # Optimizers self.gen_optimizer = gen_optimizer self.disc_optimizer = disc_optimizer # Losses self.generator_loss = generator_loss self.feature_matching_loss = feature_matching_loss self.discriminator_loss = discriminator_loss # Trackers self.gen_loss_tracker = keras.metrics.Mean(name=\"gen_loss\") self.disc_loss_tracker = keras.metrics.Mean(name=\"disc_loss\") def train_step(self, batch): x_batch_train, y_batch_train = batch with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: # Generating the audio wave gen_audio_wave = generator(x_batch_train, training=True) # Generating the features using the discriminator fake_pred = discriminator(y_batch_train) real_pred = discriminator(gen_audio_wave) # Calculating the generator losses gen_loss = generator_loss(real_pred, fake_pred) fm_loss = feature_matching_loss(real_pred, fake_pred) # Calculating final generator loss gen_fm_loss = gen_loss + 10 * fm_loss # Calculating the discriminator losses disc_loss = discriminator_loss(real_pred, fake_pred) # Calculating and applying the gradients for generator and discriminator grads_gen = gen_tape.gradient(gen_fm_loss, generator.trainable_weights) grads_disc = disc_tape.gradient(disc_loss, discriminator.trainable_weights) gen_optimizer.apply_gradients(zip(grads_gen, generator.trainable_weights)) disc_optimizer.apply_gradients(zip(grads_disc, discriminator.trainable_weights)) self.gen_loss_tracker.update_state(gen_fm_loss) self.disc_loss_tracker.update_state(disc_loss) return { \"gen_loss\": self.gen_loss_tracker.result(), \"disc_loss\": self.disc_loss_tracker.result(), } Training The paper suggests that the training with dynamic shapes takes around 400,000 steps (~500 epochs). For this example, we will run it only for a single epoch (819 steps). Longer training time (greater than 300 epochs) will almost certainly provide better results. gen_optimizer = keras.optimizers.Adam( LEARNING_RATE_GEN, beta_1=0.5, beta_2=0.9, clipnorm=1 ) disc_optimizer = keras.optimizers.Adam( LEARNING_RATE_DISC, beta_1=0.5, beta_2=0.9, clipnorm=1 ) # Start training generator = create_generator((None, 1)) discriminator = create_discriminator((None, 1)) mel_gan = MelGAN(generator, discriminator) mel_gan.compile( gen_optimizer, disc_optimizer, generator_loss, feature_matching_loss, discriminator_loss, ) mel_gan.fit( train_dataset.shuffle(200).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE), epochs=1 ) 819/819 [==============================] - 641s 696ms/step - gen_loss: 0.9761 - disc_loss: 0.9350 Testing the model The trained model can now be used for real time text-to-speech translation tasks. To test how fast the MelGAN inference can be, let us take a sample audio mel-spectrogram and convert it. Note that the actual model pipeline will not include the MelSpec layer and hence this layer will be disabled during inference. The inference input will be a mel-spectrogram processed similar to the MelSpec layer configuration. For testing this, we will create a randomly uniformly distributed tensor to simulate the behavior of the inference pipeline. # Sampling a random tensor to mimic a batch of 128 spectrograms of shape [50, 80] audio_sample = tf.random.uniform([128, 50, 80]) Timing the inference speed of a single sample. Running this, you can see that the average inference time per spectrogram ranges from 8 milliseconds to 10 milliseconds on a K80 GPU which is pretty fast. pred = generator.predict(audio_sample, batch_size=32, verbose=1) 4/4 [==============================] - 5s 280ms/step Conclusion The MelGAN is a highly effective architecture for spectral inversion that has a Mean Opinion Score (MOS) of 3.61 that considerably outperforms the Griffin Lim algorithm having a MOS of just 1.57. In contrast with this, the MelGAN compares with the state-of-the-art WaveGlow and WaveNet architectures on text-to-speech and speech enhancement tasks on the LJSpeech and VCTK datasets [1]. This tutorial highlights: The advantages of using dilated convolutions that grow with the filter size Implementation of a custom layer for on-the-fly conversion of audio waves to mel-spectrograms Effectiveness of using the feature matching loss function for training GAN generators. Further reading MelGAN paper (Kundan Kumar et al.) to understand the reasoning behind the architecture and training process For in-depth understanding of the feature matching loss, you can refer to Improved Techniques for Training GANs (Tim Salimans et al.). Classify speakers using Fast Fourier Transform (FFT) and a 1D Convnet. Introduction This example demonstrates how to create a model to classify speakers from the frequency domain representation of speech recordings, obtained via Fast Fourier Transform (FFT). It shows the following: How to use tf.data to load, preprocess and feed audio streams into a model How to create a 1D convolutional network with residual connections for audio classification. Our process: We prepare a dataset of speech samples from different speakers, with the speaker as label. We add background noise to these samples to augment our data. We take the FFT of these samples. We train a 1D convnet to predict the correct speaker given a noisy FFT speech sample. Note: This example should be run with TensorFlow 2.3 or higher, or tf-nightly. The noise samples in the dataset need to be resampled to a sampling rate of 16000 Hz before using the code in this example. In order to do this, you will need to have installed ffmpg. Setup import os import shutil import numpy as np import tensorflow as tf from tensorflow import keras from pathlib import Path from IPython.display import display, Audio # Get the data from https://www.kaggle.com/kongaevans/speaker-recognition-dataset/download # and save it to the 'Downloads' folder in your HOME directory DATASET_ROOT = os.path.join(os.path.expanduser(\"~\"), \"Downloads/16000_pcm_speeches\") # The folders in which we will put the audio samples and the noise samples AUDIO_SUBFOLDER = \"audio\" NOISE_SUBFOLDER = \"noise\" DATASET_AUDIO_PATH = os.path.join(DATASET_ROOT, AUDIO_SUBFOLDER) DATASET_NOISE_PATH = os.path.join(DATASET_ROOT, NOISE_SUBFOLDER) # Percentage of samples to use for validation VALID_SPLIT = 0.1 # Seed to use when shuffling the dataset and the noise SHUFFLE_SEED = 43 # The sampling rate to use. # This is the one used in all of the audio samples. # We will resample all of the noise to this sampling rate. # This will also be the output size of the audio wave samples # (since all samples are of 1 second long) SAMPLING_RATE = 16000 # The factor to multiply the noise with according to: # noisy_sample = sample + noise * prop * scale # where prop = sample_amplitude / noise_amplitude SCALE = 0.5 BATCH_SIZE = 128 EPOCHS = 100 Data preparation The dataset is composed of 7 folders, divided into 2 groups: Speech samples, with 5 folders for 5 different speakers. Each folder contains 1500 audio files, each 1 second long and sampled at 16000 Hz. Background noise samples, with 2 folders and a total of 6 files. These files are longer than 1 second (and originally not sampled at 16000 Hz, but we will resample them to 16000 Hz). We will use those 6 files to create 354 1-second-long noise samples to be used for training. Let's sort these 2 categories into 2 folders: An audio folder which will contain all the per-speaker speech sample folders A noise folder which will contain all the noise samples Before sorting the audio and noise categories into 2 folders, main_directory/ ...speaker_a/ ...speaker_b/ ...speaker_c/ ...speaker_d/ ...speaker_e/ ...other/ ..._background_noise_/ After sorting, we end up with the following structure: main_directory/ ...audio/ ......speaker_a/ ......speaker_b/ ......speaker_c/ ......speaker_d/ ......speaker_e/ ...noise/ ......other/ ......_background_noise_/ # If folder `audio`, does not exist, create it, otherwise do nothing if os.path.exists(DATASET_AUDIO_PATH) is False: os.makedirs(DATASET_AUDIO_PATH) # If folder `noise`, does not exist, create it, otherwise do nothing if os.path.exists(DATASET_NOISE_PATH) is False: os.makedirs(DATASET_NOISE_PATH) for folder in os.listdir(DATASET_ROOT): if os.path.isdir(os.path.join(DATASET_ROOT, folder)): if folder in [AUDIO_SUBFOLDER, NOISE_SUBFOLDER]: # If folder is `audio` or `noise`, do nothing continue elif folder in [\"other\", \"_background_noise_\"]: # If folder is one of the folders that contains noise samples, # move it to the `noise` folder shutil.move( os.path.join(DATASET_ROOT, folder), os.path.join(DATASET_NOISE_PATH, folder), ) else: # Otherwise, it should be a speaker folder, then move it to # `audio` folder shutil.move( os.path.join(DATASET_ROOT, folder), os.path.join(DATASET_AUDIO_PATH, folder), ) Noise preparation In this section: We load all noise samples (which should have been resampled to 16000) We split those noise samples to chuncks of 16000 samples which correspond to 1 second duration each # Get the list of all noise files noise_paths = [] for subdir in os.listdir(DATASET_NOISE_PATH): subdir_path = Path(DATASET_NOISE_PATH) / subdir if os.path.isdir(subdir_path): noise_paths += [ os.path.join(subdir_path, filepath) for filepath in os.listdir(subdir_path) if filepath.endswith(\".wav\") ] print( \"Found {} files belonging to {} directories\".format( len(noise_paths), len(os.listdir(DATASET_NOISE_PATH)) ) ) Found 6 files belonging to 2 directories Resample all noise samples to 16000 Hz command = ( \"for dir in `ls -1 \" + DATASET_NOISE_PATH + \"`; do \" \"for file in `ls -1 \" + DATASET_NOISE_PATH + \"/$dir/*.wav`; do \" \"sample_rate=`ffprobe -hide_banner -loglevel panic -show_streams \" \"$file | grep sample_rate | cut -f2 -d=`; \" \"if [ $sample_rate -ne 16000 ]; then \" \"ffmpeg -hide_banner -loglevel panic -y \" \"-i $file -ar 16000 temp.wav; \" \"mv temp.wav $file; \" \"fi; done; done\" ) os.system(command) # Split noise into chunks of 16000 each def load_noise_sample(path): sample, sampling_rate = tf.audio.decode_wav( tf.io.read_file(path), desired_channels=1 ) if sampling_rate == SAMPLING_RATE: # Number of slices of 16000 each that can be generated from the noise sample slices = int(sample.shape[0] / SAMPLING_RATE) sample = tf.split(sample[: slices * SAMPLING_RATE], slices) return sample else: print(\"Sampling rate for {} is incorrect. Ignoring it\".format(path)) return None noises = [] for path in noise_paths: sample = load_noise_sample(path) if sample: noises.extend(sample) noises = tf.stack(noises) print( \"{} noise files were split into {} noise samples where each is {} sec. long\".format( len(noise_paths), noises.shape[0], noises.shape[1] // SAMPLING_RATE ) ) 6 noise files were split into 354 noise samples where each is 1 sec. long Dataset generation def paths_and_labels_to_dataset(audio_paths, labels): \"\"\"Constructs a dataset of audios and labels.\"\"\" path_ds = tf.data.Dataset.from_tensor_slices(audio_paths) audio_ds = path_ds.map(lambda x: path_to_audio(x)) label_ds = tf.data.Dataset.from_tensor_slices(labels) return tf.data.Dataset.zip((audio_ds, label_ds)) def path_to_audio(path): \"\"\"Reads and decodes an audio file.\"\"\" audio = tf.io.read_file(path) audio, _ = tf.audio.decode_wav(audio, 1, SAMPLING_RATE) return audio def add_noise(audio, noises=None, scale=0.5): if noises is not None: # Create a random tensor of the same size as audio ranging from # 0 to the number of noise stream samples that we have. tf_rnd = tf.random.uniform( (tf.shape(audio)[0],), 0, noises.shape[0], dtype=tf.int32 ) noise = tf.gather(noises, tf_rnd, axis=0) # Get the amplitude proportion between the audio and the noise prop = tf.math.reduce_max(audio, axis=1) / tf.math.reduce_max(noise, axis=1) prop = tf.repeat(tf.expand_dims(prop, axis=1), tf.shape(audio)[1], axis=1) # Adding the rescaled noise to audio audio = audio + noise * prop * scale return audio def audio_to_fft(audio): # Since tf.signal.fft applies FFT on the innermost dimension, # we need to squeeze the dimensions and then expand them again # after FFT audio = tf.squeeze(audio, axis=-1) fft = tf.signal.fft( tf.cast(tf.complex(real=audio, imag=tf.zeros_like(audio)), tf.complex64) ) fft = tf.expand_dims(fft, axis=-1) # Return the absolute value of the first half of the FFT # which represents the positive frequencies return tf.math.abs(fft[:, : (audio.shape[1] // 2), :]) # Get the list of audio file paths along with their corresponding labels class_names = os.listdir(DATASET_AUDIO_PATH) print(\"Our class names: {}\".format(class_names,)) audio_paths = [] labels = [] for label, name in enumerate(class_names): print(\"Processing speaker {}\".format(name,)) dir_path = Path(DATASET_AUDIO_PATH) / name speaker_sample_paths = [ os.path.join(dir_path, filepath) for filepath in os.listdir(dir_path) if filepath.endswith(\".wav\") ] audio_paths += speaker_sample_paths labels += [label] * len(speaker_sample_paths) print( \"Found {} files belonging to {} classes.\".format(len(audio_paths), len(class_names)) ) # Shuffle rng = np.random.RandomState(SHUFFLE_SEED) rng.shuffle(audio_paths) rng = np.random.RandomState(SHUFFLE_SEED) rng.shuffle(labels) # Split into training and validation num_val_samples = int(VALID_SPLIT * len(audio_paths)) print(\"Using {} files for training.\".format(len(audio_paths) - num_val_samples)) train_audio_paths = audio_paths[:-num_val_samples] train_labels = labels[:-num_val_samples] print(\"Using {} files for validation.\".format(num_val_samples)) valid_audio_paths = audio_paths[-num_val_samples:] valid_labels = labels[-num_val_samples:] # Create 2 datasets, one for training and the other for validation train_ds = paths_and_labels_to_dataset(train_audio_paths, train_labels) train_ds = train_ds.shuffle(buffer_size=BATCH_SIZE * 8, seed=SHUFFLE_SEED).batch( BATCH_SIZE ) valid_ds = paths_and_labels_to_dataset(valid_audio_paths, valid_labels) valid_ds = valid_ds.shuffle(buffer_size=32 * 8, seed=SHUFFLE_SEED).batch(32) # Add noise to the training set train_ds = train_ds.map( lambda x, y: (add_noise(x, noises, scale=SCALE), y), num_parallel_calls=tf.data.AUTOTUNE, ) # Transform audio wave to the frequency domain using `audio_to_fft` train_ds = train_ds.map( lambda x, y: (audio_to_fft(x), y), num_parallel_calls=tf.data.AUTOTUNE ) train_ds = train_ds.prefetch(tf.data.AUTOTUNE) valid_ds = valid_ds.map( lambda x, y: (audio_to_fft(x), y), num_parallel_calls=tf.data.AUTOTUNE ) valid_ds = valid_ds.prefetch(tf.data.AUTOTUNE) Our class names: ['Julia_Gillard', 'Jens_Stoltenberg', 'Nelson_Mandela', 'Magaret_Tarcher', 'Benjamin_Netanyau'] Processing speaker Julia_Gillard Processing speaker Jens_Stoltenberg Processing speaker Nelson_Mandela Processing speaker Magaret_Tarcher Processing speaker Benjamin_Netanyau Found 7501 files belonging to 5 classes. Using 6751 files for training. Using 750 files for validation. Model Definition def residual_block(x, filters, conv_num=3, activation=\"relu\"): # Shortcut s = keras.layers.Conv1D(filters, 1, padding=\"same\")(x) for i in range(conv_num - 1): x = keras.layers.Conv1D(filters, 3, padding=\"same\")(x) x = keras.layers.Activation(activation)(x) x = keras.layers.Conv1D(filters, 3, padding=\"same\")(x) x = keras.layers.Add()([x, s]) x = keras.layers.Activation(activation)(x) return keras.layers.MaxPool1D(pool_size=2, strides=2)(x) def build_model(input_shape, num_classes): inputs = keras.layers.Input(shape=input_shape, name=\"input\") x = residual_block(inputs, 16, 2) x = residual_block(x, 32, 2) x = residual_block(x, 64, 3) x = residual_block(x, 128, 3) x = residual_block(x, 128, 3) x = keras.layers.AveragePooling1D(pool_size=3, strides=3)(x) x = keras.layers.Flatten()(x) x = keras.layers.Dense(256, activation=\"relu\")(x) x = keras.layers.Dense(128, activation=\"relu\")(x) outputs = keras.layers.Dense(num_classes, activation=\"softmax\", name=\"output\")(x) return keras.models.Model(inputs=inputs, outputs=outputs) model = build_model((SAMPLING_RATE // 2, 1), len(class_names)) model.summary() # Compile the model using Adam's default learning rate model.compile( optimizer=\"Adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"] ) # Add callbacks: # 'EarlyStopping' to stop training when the model is not enhancing anymore # 'ModelCheckPoint' to always keep the model that has the best val_accuracy model_save_filename = \"model.h5\" earlystopping_cb = keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True) mdlcheckpoint_cb = keras.callbacks.ModelCheckpoint( model_save_filename, monitor=\"val_accuracy\", save_best_only=True ) Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input (InputLayer) [(None, 8000, 1)] 0 __________________________________________________________________________________________________ conv1d_1 (Conv1D) (None, 8000, 16) 64 input[0][0] __________________________________________________________________________________________________ activation (Activation) (None, 8000, 16) 0 conv1d_1[0][0] __________________________________________________________________________________________________ conv1d_2 (Conv1D) (None, 8000, 16) 784 activation[0][0] __________________________________________________________________________________________________ conv1d (Conv1D) (None, 8000, 16) 32 input[0][0] __________________________________________________________________________________________________ add (Add) (None, 8000, 16) 0 conv1d_2[0][0] conv1d[0][0] __________________________________________________________________________________________________ activation_1 (Activation) (None, 8000, 16) 0 add[0][0] __________________________________________________________________________________________________ max_pooling1d (MaxPooling1D) (None, 4000, 16) 0 activation_1[0][0] __________________________________________________________________________________________________ conv1d_4 (Conv1D) (None, 4000, 32) 1568 max_pooling1d[0][0] __________________________________________________________________________________________________ activation_2 (Activation) (None, 4000, 32) 0 conv1d_4[0][0] __________________________________________________________________________________________________ conv1d_5 (Conv1D) (None, 4000, 32) 3104 activation_2[0][0] __________________________________________________________________________________________________ conv1d_3 (Conv1D) (None, 4000, 32) 544 max_pooling1d[0][0] __________________________________________________________________________________________________ add_1 (Add) (None, 4000, 32) 0 conv1d_5[0][0] conv1d_3[0][0] __________________________________________________________________________________________________ activation_3 (Activation) (None, 4000, 32) 0 add_1[0][0] __________________________________________________________________________________________________ max_pooling1d_1 (MaxPooling1D) (None, 2000, 32) 0 activation_3[0][0] __________________________________________________________________________________________________ conv1d_7 (Conv1D) (None, 2000, 64) 6208 max_pooling1d_1[0][0] __________________________________________________________________________________________________ activation_4 (Activation) (None, 2000, 64) 0 conv1d_7[0][0] __________________________________________________________________________________________________ conv1d_8 (Conv1D) (None, 2000, 64) 12352 activation_4[0][0] __________________________________________________________________________________________________ activation_5 (Activation) (None, 2000, 64) 0 conv1d_8[0][0] __________________________________________________________________________________________________ conv1d_9 (Conv1D) (None, 2000, 64) 12352 activation_5[0][0] __________________________________________________________________________________________________ conv1d_6 (Conv1D) (None, 2000, 64) 2112 max_pooling1d_1[0][0] __________________________________________________________________________________________________ add_2 (Add) (None, 2000, 64) 0 conv1d_9[0][0] conv1d_6[0][0] __________________________________________________________________________________________________ activation_6 (Activation) (None, 2000, 64) 0 add_2[0][0] __________________________________________________________________________________________________ max_pooling1d_2 (MaxPooling1D) (None, 1000, 64) 0 activation_6[0][0] __________________________________________________________________________________________________ conv1d_11 (Conv1D) (None, 1000, 128) 24704 max_pooling1d_2[0][0] __________________________________________________________________________________________________ activation_7 (Activation) (None, 1000, 128) 0 conv1d_11[0][0] __________________________________________________________________________________________________ conv1d_12 (Conv1D) (None, 1000, 128) 49280 activation_7[0][0] __________________________________________________________________________________________________ activation_8 (Activation) (None, 1000, 128) 0 conv1d_12[0][0] __________________________________________________________________________________________________ conv1d_13 (Conv1D) (None, 1000, 128) 49280 activation_8[0][0] __________________________________________________________________________________________________ conv1d_10 (Conv1D) (None, 1000, 128) 8320 max_pooling1d_2[0][0] __________________________________________________________________________________________________ add_3 (Add) (None, 1000, 128) 0 conv1d_13[0][0] conv1d_10[0][0] __________________________________________________________________________________________________ activation_9 (Activation) (None, 1000, 128) 0 add_3[0][0] __________________________________________________________________________________________________ max_pooling1d_3 (MaxPooling1D) (None, 500, 128) 0 activation_9[0][0] __________________________________________________________________________________________________ conv1d_15 (Conv1D) (None, 500, 128) 49280 max_pooling1d_3[0][0] __________________________________________________________________________________________________ activation_10 (Activation) (None, 500, 128) 0 conv1d_15[0][0] __________________________________________________________________________________________________ conv1d_16 (Conv1D) (None, 500, 128) 49280 activation_10[0][0] __________________________________________________________________________________________________ activation_11 (Activation) (None, 500, 128) 0 conv1d_16[0][0] __________________________________________________________________________________________________ conv1d_17 (Conv1D) (None, 500, 128) 49280 activation_11[0][0] __________________________________________________________________________________________________ conv1d_14 (Conv1D) (None, 500, 128) 16512 max_pooling1d_3[0][0] __________________________________________________________________________________________________ add_4 (Add) (None, 500, 128) 0 conv1d_17[0][0] conv1d_14[0][0] __________________________________________________________________________________________________ activation_12 (Activation) (None, 500, 128) 0 add_4[0][0] __________________________________________________________________________________________________ max_pooling1d_4 (MaxPooling1D) (None, 250, 128) 0 activation_12[0][0] __________________________________________________________________________________________________ average_pooling1d (AveragePooli (None, 83, 128) 0 max_pooling1d_4[0][0] __________________________________________________________________________________________________ flatten (Flatten) (None, 10624) 0 average_pooling1d[0][0] __________________________________________________________________________________________________ dense (Dense) (None, 256) 2720000 flatten[0][0] __________________________________________________________________________________________________ dense_1 (Dense) (None, 128) 32896 dense[0][0] __________________________________________________________________________________________________ output (Dense) (None, 5) 645 dense_1[0][0] ================================================================================================== Total params: 3,088,597 Trainable params: 3,088,597 Non-trainable params: 0 __________________________________________________________________________________________________ Training history = model.fit( train_ds, epochs=EPOCHS, validation_data=valid_ds, callbacks=[earlystopping_cb, mdlcheckpoint_cb], ) Epoch 1/100 53/53 [==============================] - 62s 1s/step - loss: 1.0107 - accuracy: 0.6929 - val_loss: 0.3367 - val_accuracy: 0.8640 Epoch 2/100 53/53 [==============================] - 61s 1s/step - loss: 0.2863 - accuracy: 0.8926 - val_loss: 0.2814 - val_accuracy: 0.8813 Epoch 3/100 53/53 [==============================] - 61s 1s/step - loss: 0.2293 - accuracy: 0.9104 - val_loss: 0.2054 - val_accuracy: 0.9160 Epoch 4/100 53/53 [==============================] - 63s 1s/step - loss: 0.1750 - accuracy: 0.9320 - val_loss: 0.1668 - val_accuracy: 0.9320 Epoch 5/100 53/53 [==============================] - 61s 1s/step - loss: 0.2044 - accuracy: 0.9206 - val_loss: 0.1658 - val_accuracy: 0.9347 Epoch 6/100 53/53 [==============================] - 61s 1s/step - loss: 0.1407 - accuracy: 0.9415 - val_loss: 0.0888 - val_accuracy: 0.9720 Epoch 7/100 53/53 [==============================] - 61s 1s/step - loss: 0.1047 - accuracy: 0.9600 - val_loss: 0.1113 - val_accuracy: 0.9587 Epoch 8/100 53/53 [==============================] - 60s 1s/step - loss: 0.1077 - accuracy: 0.9573 - val_loss: 0.0819 - val_accuracy: 0.9693 Epoch 9/100 53/53 [==============================] - 61s 1s/step - loss: 0.0998 - accuracy: 0.9640 - val_loss: 0.1586 - val_accuracy: 0.9427 Epoch 10/100 53/53 [==============================] - 63s 1s/step - loss: 0.1004 - accuracy: 0.9621 - val_loss: 0.1504 - val_accuracy: 0.9333 Epoch 11/100 53/53 [==============================] - 60s 1s/step - loss: 0.0902 - accuracy: 0.9695 - val_loss: 0.1016 - val_accuracy: 0.9600 Epoch 12/100 53/53 [==============================] - 61s 1s/step - loss: 0.0773 - accuracy: 0.9714 - val_loss: 0.0647 - val_accuracy: 0.9800 Epoch 13/100 53/53 [==============================] - 63s 1s/step - loss: 0.0797 - accuracy: 0.9699 - val_loss: 0.0485 - val_accuracy: 0.9853 Epoch 14/100 53/53 [==============================] - 61s 1s/step - loss: 0.0750 - accuracy: 0.9727 - val_loss: 0.0601 - val_accuracy: 0.9787 Epoch 15/100 53/53 [==============================] - 62s 1s/step - loss: 0.0629 - accuracy: 0.9766 - val_loss: 0.0476 - val_accuracy: 0.9787 Epoch 16/100 53/53 [==============================] - 63s 1s/step - loss: 0.0564 - accuracy: 0.9793 - val_loss: 0.0565 - val_accuracy: 0.9813 Epoch 17/100 53/53 [==============================] - 61s 1s/step - loss: 0.0545 - accuracy: 0.9809 - val_loss: 0.0325 - val_accuracy: 0.9893 Epoch 18/100 53/53 [==============================] - 61s 1s/step - loss: 0.0415 - accuracy: 0.9859 - val_loss: 0.0776 - val_accuracy: 0.9693 Epoch 19/100 53/53 [==============================] - 61s 1s/step - loss: 0.0537 - accuracy: 0.9810 - val_loss: 0.0647 - val_accuracy: 0.9853 Epoch 20/100 53/53 [==============================] - 62s 1s/step - loss: 0.0556 - accuracy: 0.9802 - val_loss: 0.0500 - val_accuracy: 0.9880 Epoch 21/100 53/53 [==============================] - 63s 1s/step - loss: 0.0486 - accuracy: 0.9828 - val_loss: 0.0470 - val_accuracy: 0.9827 Epoch 22/100 53/53 [==============================] - 61s 1s/step - loss: 0.0479 - accuracy: 0.9825 - val_loss: 0.0918 - val_accuracy: 0.9693 Epoch 23/100 53/53 [==============================] - 61s 1s/step - loss: 0.0446 - accuracy: 0.9834 - val_loss: 0.0429 - val_accuracy: 0.9867 Epoch 24/100 53/53 [==============================] - 61s 1s/step - loss: 0.0309 - accuracy: 0.9889 - val_loss: 0.0473 - val_accuracy: 0.9867 Epoch 25/100 53/53 [==============================] - 63s 1s/step - loss: 0.0341 - accuracy: 0.9895 - val_loss: 0.0244 - val_accuracy: 0.9907 Epoch 26/100 53/53 [==============================] - 60s 1s/step - loss: 0.0357 - accuracy: 0.9874 - val_loss: 0.0289 - val_accuracy: 0.9893 Epoch 27/100 53/53 [==============================] - 61s 1s/step - loss: 0.0331 - accuracy: 0.9893 - val_loss: 0.0246 - val_accuracy: 0.9920 Epoch 28/100 53/53 [==============================] - 61s 1s/step - loss: 0.0339 - accuracy: 0.9879 - val_loss: 0.0646 - val_accuracy: 0.9787 Epoch 29/100 53/53 [==============================] - 61s 1s/step - loss: 0.0250 - accuracy: 0.9910 - val_loss: 0.0146 - val_accuracy: 0.9947 Epoch 30/100 53/53 [==============================] - 63s 1s/step - loss: 0.0343 - accuracy: 0.9883 - val_loss: 0.0318 - val_accuracy: 0.9893 Epoch 31/100 53/53 [==============================] - 61s 1s/step - loss: 0.0312 - accuracy: 0.9893 - val_loss: 0.0270 - val_accuracy: 0.9880 Epoch 32/100 53/53 [==============================] - 61s 1s/step - loss: 0.0201 - accuracy: 0.9917 - val_loss: 0.0264 - val_accuracy: 0.9893 Epoch 33/100 53/53 [==============================] - 61s 1s/step - loss: 0.0371 - accuracy: 0.9876 - val_loss: 0.0722 - val_accuracy: 0.9773 Epoch 34/100 53/53 [==============================] - 61s 1s/step - loss: 0.0533 - accuracy: 0.9828 - val_loss: 0.0161 - val_accuracy: 0.9947 Epoch 35/100 53/53 [==============================] - 61s 1s/step - loss: 0.0258 - accuracy: 0.9911 - val_loss: 0.0277 - val_accuracy: 0.9867 Epoch 36/100 53/53 [==============================] - 60s 1s/step - loss: 0.0261 - accuracy: 0.9901 - val_loss: 0.0542 - val_accuracy: 0.9787 Epoch 37/100 53/53 [==============================] - 60s 1s/step - loss: 0.0368 - accuracy: 0.9877 - val_loss: 0.0699 - val_accuracy: 0.9813 Epoch 38/100 53/53 [==============================] - 63s 1s/step - loss: 0.0251 - accuracy: 0.9890 - val_loss: 0.0206 - val_accuracy: 0.9907 Epoch 39/100 53/53 [==============================] - 62s 1s/step - loss: 0.0220 - accuracy: 0.9913 - val_loss: 0.0211 - val_accuracy: 0.9947 Evaluation print(model.evaluate(valid_ds)) 24/24 [==============================] - 6s 244ms/step - loss: 0.0146 - accuracy: 0.9947 [0.014629718847572803, 0.9946666955947876] We get ~ 98% validation accuracy. Demonstration Let's take some samples and: Predict the speaker Compare the prediction with the real speaker Listen to the audio to see that despite the samples being noisy, the model is still pretty accurate SAMPLES_TO_DISPLAY = 10 test_ds = paths_and_labels_to_dataset(valid_audio_paths, valid_labels) test_ds = test_ds.shuffle(buffer_size=BATCH_SIZE * 8, seed=SHUFFLE_SEED).batch( BATCH_SIZE ) test_ds = test_ds.map(lambda x, y: (add_noise(x, noises, scale=SCALE), y)) for audios, labels in test_ds.take(1): # Get the signal FFT ffts = audio_to_fft(audios) # Predict y_pred = model.predict(ffts) # Take random samples rnd = np.random.randint(0, BATCH_SIZE, SAMPLES_TO_DISPLAY) audios = audios.numpy()[rnd, :, :] labels = labels.numpy()[rnd] y_pred = np.argmax(y_pred, axis=-1)[rnd] for index in range(SAMPLES_TO_DISPLAY): # For every sample, print the true and predicted label # as well as run the voice with the noise print( \"Speaker: {} - Predicted: {}\".format( class_names[labels[index]], class_names[y_pred[index]], ) ) display(Audio(audios[index, :, :].squeeze(), rate=SAMPLING_RATE)) Train a 3D convolutional neural network to predict presence of pneumonia. Introduction This example will show the steps needed to build a 3D convolutional neural network (CNN) to predict the presence of viral pneumonia in computer tomography (CT) scans. 2D CNNs are commonly used to process RGB images (3 channels). A 3D CNN is simply the 3D equivalent: it takes as input a 3D volume or a sequence of 2D frames (e.g. slices in a CT scan), 3D CNNs are a powerful model for learning representations for volumetric data. References A survey on Deep Learning Advances on Different 3D DataRepresentations VoxNet: A 3D Convolutional Neural Network for Real-Time Object Recognition FusionNet: 3D Object Classification Using MultipleData Representations Uniformizing Techniques to Process CT scans with 3D CNNs for Tuberculosis Prediction Setup import os import zipfile import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Downloading the MosMedData: Chest CT Scans with COVID-19 Related Findings In this example, we use a subset of the MosMedData: Chest CT Scans with COVID-19 Related Findings. This dataset consists of lung CT scans with COVID-19 related findings, as well as without such findings. We will be using the associated radiological findings of the CT scans as labels to build a classifier to predict presence of viral pneumonia. Hence, the task is a binary classification problem. # Download url of normal CT scans. url = \"https://github.com/hasibzunair/3D-image-classification-tutorial/releases/download/v0.2/CT-0.zip\" filename = os.path.join(os.getcwd(), \"CT-0.zip\") keras.utils.get_file(filename, url) # Download url of abnormal CT scans. url = \"https://github.com/hasibzunair/3D-image-classification-tutorial/releases/download/v0.2/CT-23.zip\" filename = os.path.join(os.getcwd(), \"CT-23.zip\") keras.utils.get_file(filename, url) # Make a directory to store the data. os.makedirs(\"MosMedData\") # Unzip data in the newly created directory. with zipfile.ZipFile(\"CT-0.zip\", \"r\") as z_fp: z_fp.extractall(\"./MosMedData/\") with zipfile.ZipFile(\"CT-23.zip\", \"r\") as z_fp: z_fp.extractall(\"./MosMedData/\") Downloading data from https://github.com/hasibzunair/3D-image-classification-tutorial/releases/download/v0.2/CT-0.zip 1065476096/1065471431 [==============================] - 236s 0us/step Downloading data from https://github.com/hasibzunair/3D-image-classification-tutorial/releases/download/v0.2/CT-23.zip 271171584/1045162547 [======>.......................] - ETA: 2:56 Loading data and preprocessing The files are provided in Nifti format with the extension .nii. To read the scans, we use the nibabel package. You can install the package via pip install nibabel. CT scans store raw voxel intensity in Hounsfield units (HU). They range from -1024 to above 2000 in this dataset. Above 400 are bones with different radiointensity, so this is used as a higher bound. A threshold between -1000 and 400 is commonly used to normalize CT scans. To process the data, we do the following: We first rotate the volumes by 90 degrees, so the orientation is fixed We scale the HU values to be between 0 and 1. We resize width, height and depth. Here we define several helper functions to process the data. These functions will be used when building training and validation datasets. import nibabel as nib from scipy import ndimage def read_nifti_file(filepath): \"\"\"Read and load volume\"\"\" # Read file scan = nib.load(filepath) # Get raw data scan = scan.get_fdata() return scan def normalize(volume): \"\"\"Normalize the volume\"\"\" min = -1000 max = 400 volume[volume < min] = min volume[volume > max] = max volume = (volume - min) / (max - min) volume = volume.astype(\"float32\") return volume def resize_volume(img): \"\"\"Resize across z-axis\"\"\" # Set the desired depth desired_depth = 64 desired_width = 128 desired_height = 128 # Get current depth current_depth = img.shape[-1] current_width = img.shape[0] current_height = img.shape[1] # Compute depth factor depth = current_depth / desired_depth width = current_width / desired_width height = current_height / desired_height depth_factor = 1 / depth width_factor = 1 / width height_factor = 1 / height # Rotate img = ndimage.rotate(img, 90, reshape=False) # Resize across z-axis img = ndimage.zoom(img, (width_factor, height_factor, depth_factor), order=1) return img def process_scan(path): \"\"\"Read and resize volume\"\"\" # Read scan volume = read_nifti_file(path) # Normalize volume = normalize(volume) # Resize width, height and depth volume = resize_volume(volume) return volume Let's read the paths of the CT scans from the class directories. # Folder \"CT-0\" consist of CT scans having normal lung tissue, # no CT-signs of viral pneumonia. normal_scan_paths = [ os.path.join(os.getcwd(), \"MosMedData/CT-0\", x) for x in os.listdir(\"MosMedData/CT-0\") ] # Folder \"CT-23\" consist of CT scans having several ground-glass opacifications, # involvement of lung parenchyma. abnormal_scan_paths = [ os.path.join(os.getcwd(), \"MosMedData/CT-23\", x) for x in os.listdir(\"MosMedData/CT-23\") ] print(\"CT scans with normal lung tissue: \" + str(len(normal_scan_paths))) print(\"CT scans with abnormal lung tissue: \" + str(len(abnormal_scan_paths))) CT scans with normal lung tissue: 100 CT scans with abnormal lung tissue: 100 Build train and validation datasets Read the scans from the class directories and assign labels. Downsample the scans to have shape of 128x128x64. Rescale the raw HU values to the range 0 to 1. Lastly, split the dataset into train and validation subsets. # Read and process the scans. # Each scan is resized across height, width, and depth and rescaled. abnormal_scans = np.array([process_scan(path) for path in abnormal_scan_paths]) normal_scans = np.array([process_scan(path) for path in normal_scan_paths]) # For the CT scans having presence of viral pneumonia # assign 1, for the normal ones assign 0. abnormal_labels = np.array([1 for _ in range(len(abnormal_scans))]) normal_labels = np.array([0 for _ in range(len(normal_scans))]) # Split data in the ratio 70-30 for training and validation. x_train = np.concatenate((abnormal_scans[:70], normal_scans[:70]), axis=0) y_train = np.concatenate((abnormal_labels[:70], normal_labels[:70]), axis=0) x_val = np.concatenate((abnormal_scans[70:], normal_scans[70:]), axis=0) y_val = np.concatenate((abnormal_labels[70:], normal_labels[70:]), axis=0) print( \"Number of samples in train and validation are %d and %d.\" % (x_train.shape[0], x_val.shape[0]) ) Number of samples in train and validation are 140 and 60. Data augmentation The CT scans also augmented by rotating at random angles during training. Since the data is stored in rank-3 tensors of shape (samples, height, width, depth), we add a dimension of size 1 at axis 4 to be able to perform 3D convolutions on the data. The new shape is thus (samples, height, width, depth, 1). There are different kinds of preprocessing and augmentation techniques out there, this example shows a few simple ones to get started. import random from scipy import ndimage @tf.function def rotate(volume): \"\"\"Rotate the volume by a few degrees\"\"\" def scipy_rotate(volume): # define some rotation angles angles = [-20, -10, -5, 5, 10, 20] # pick angles at random angle = random.choice(angles) # rotate volume volume = ndimage.rotate(volume, angle, reshape=False) volume[volume < 0] = 0 volume[volume > 1] = 1 return volume augmented_volume = tf.numpy_function(scipy_rotate, [volume], tf.float32) return augmented_volume def train_preprocessing(volume, label): \"\"\"Process training data by rotating and adding a channel.\"\"\" # Rotate volume volume = rotate(volume) volume = tf.expand_dims(volume, axis=3) return volume, label def validation_preprocessing(volume, label): \"\"\"Process validation data by only adding a channel.\"\"\" volume = tf.expand_dims(volume, axis=3) return volume, label While defining the train and validation data loader, the training data is passed through and augmentation function which randomly rotates volume at different angles. Note that both training and validation data are already rescaled to have values between 0 and 1. # Define data loaders. train_loader = tf.data.Dataset.from_tensor_slices((x_train, y_train)) validation_loader = tf.data.Dataset.from_tensor_slices((x_val, y_val)) batch_size = 2 # Augment the on the fly during training. train_dataset = ( train_loader.shuffle(len(x_train)) .map(train_preprocessing) .batch(batch_size) .prefetch(2) ) # Only rescale. validation_dataset = ( validation_loader.shuffle(len(x_val)) .map(validation_preprocessing) .batch(batch_size) .prefetch(2) ) Visualize an augmented CT scan. import matplotlib.pyplot as plt data = train_dataset.take(1) images, labels = list(data)[0] images = images.numpy() image = images[0] print(\"Dimension of the CT scan is:\", image.shape) plt.imshow(np.squeeze(image[:, :, 30]), cmap=\"gray\") Dimension of the CT scan is: (128, 128, 64, 1) png Since a CT scan has many slices, let's visualize a montage of the slices. def plot_slices(num_rows, num_columns, width, height, data): \"\"\"Plot a montage of 20 CT slices\"\"\" data = np.rot90(np.array(data)) data = np.transpose(data) data = np.reshape(data, (num_rows, num_columns, width, height)) rows_data, columns_data = data.shape[0], data.shape[1] heights = [slc[0].shape[0] for slc in data] widths = [slc.shape[1] for slc in data[0]] fig_width = 12.0 fig_height = fig_width * sum(heights) / sum(widths) f, axarr = plt.subplots( rows_data, columns_data, figsize=(fig_width, fig_height), gridspec_kw={\"height_ratios\": heights}, ) for i in range(rows_data): for j in range(columns_data): axarr[i, j].imshow(data[i][j], cmap=\"gray\") axarr[i, j].axis(\"off\") plt.subplots_adjust(wspace=0, hspace=0, left=0, right=1, bottom=0, top=1) plt.show() # Visualize montage of slices. # 4 rows and 10 columns for 100 slices of the CT scan. plot_slices(4, 10, 128, 128, image[:, :, :40]) png Define a 3D convolutional neural network To make the model easier to understand, we structure it into blocks. The architecture of the 3D CNN used in this example is based on this paper. def get_model(width=128, height=128, depth=64): \"\"\"Build a 3D convolutional neural network model.\"\"\" inputs = keras.Input((width, height, depth, 1)) x = layers.Conv3D(filters=64, kernel_size=3, activation=\"relu\")(inputs) x = layers.MaxPool3D(pool_size=2)(x) x = layers.BatchNormalization()(x) x = layers.Conv3D(filters=64, kernel_size=3, activation=\"relu\")(x) x = layers.MaxPool3D(pool_size=2)(x) x = layers.BatchNormalization()(x) x = layers.Conv3D(filters=128, kernel_size=3, activation=\"relu\")(x) x = layers.MaxPool3D(pool_size=2)(x) x = layers.BatchNormalization()(x) x = layers.Conv3D(filters=256, kernel_size=3, activation=\"relu\")(x) x = layers.MaxPool3D(pool_size=2)(x) x = layers.BatchNormalization()(x) x = layers.GlobalAveragePooling3D()(x) x = layers.Dense(units=512, activation=\"relu\")(x) x = layers.Dropout(0.3)(x) outputs = layers.Dense(units=1, activation=\"sigmoid\")(x) # Define the model. model = keras.Model(inputs, outputs, name=\"3dcnn\") return model # Build model. model = get_model(width=128, height=128, depth=64) model.summary() Model: \"3dcnn\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 128, 128, 64, 1)] 0 _________________________________________________________________ conv3d (Conv3D) (None, 126, 126, 62, 64) 1792 _________________________________________________________________ max_pooling3d (MaxPooling3D) (None, 63, 63, 31, 64) 0 _________________________________________________________________ batch_normalization (BatchNo (None, 63, 63, 31, 64) 256 _________________________________________________________________ conv3d_1 (Conv3D) (None, 61, 61, 29, 64) 110656 _________________________________________________________________ max_pooling3d_1 (MaxPooling3 (None, 30, 30, 14, 64) 0 _________________________________________________________________ batch_normalization_1 (Batch (None, 30, 30, 14, 64) 256 _________________________________________________________________ conv3d_2 (Conv3D) (None, 28, 28, 12, 128) 221312 _________________________________________________________________ max_pooling3d_2 (MaxPooling3 (None, 14, 14, 6, 128) 0 _________________________________________________________________ batch_normalization_2 (Batch (None, 14, 14, 6, 128) 512 _________________________________________________________________ conv3d_3 (Conv3D) (None, 12, 12, 4, 256) 884992 _________________________________________________________________ max_pooling3d_3 (MaxPooling3 (None, 6, 6, 2, 256) 0 _________________________________________________________________ batch_normalization_3 (Batch (None, 6, 6, 2, 256) 1024 _________________________________________________________________ global_average_pooling3d (Gl (None, 256) 0 _________________________________________________________________ dense (Dense) (None, 512) 131584 _________________________________________________________________ dropout (Dropout) (None, 512) 0 _________________________________________________________________ dense_1 (Dense) (None, 1) 513 ================================================================= Total params: 1,352,897 Trainable params: 1,351,873 Non-trainable params: 1,024 _________________________________________________________________ Train model # Compile model. initial_learning_rate = 0.0001 lr_schedule = keras.optimizers.schedules.ExponentialDecay( initial_learning_rate, decay_steps=100000, decay_rate=0.96, staircase=True ) model.compile( loss=\"binary_crossentropy\", optimizer=keras.optimizers.Adam(learning_rate=lr_schedule), metrics=[\"acc\"], ) # Define callbacks. checkpoint_cb = keras.callbacks.ModelCheckpoint( \"3d_image_classification.h5\", save_best_only=True ) early_stopping_cb = keras.callbacks.EarlyStopping(monitor=\"val_acc\", patience=15) # Train the model, doing validation at the end of each epoch epochs = 100 model.fit( train_dataset, validation_data=validation_dataset, epochs=epochs, shuffle=True, verbose=2, callbacks=[checkpoint_cb, early_stopping_cb], ) Epoch 1/100 70/70 - 12s - loss: 0.7031 - acc: 0.5286 - val_loss: 1.1421 - val_acc: 0.5000 Epoch 2/100 70/70 - 12s - loss: 0.6769 - acc: 0.5929 - val_loss: 1.3491 - val_acc: 0.5000 Epoch 3/100 70/70 - 12s - loss: 0.6543 - acc: 0.6286 - val_loss: 1.5108 - val_acc: 0.5000 Epoch 4/100 70/70 - 12s - loss: 0.6236 - acc: 0.6714 - val_loss: 2.5255 - val_acc: 0.5000 Epoch 5/100 70/70 - 12s - loss: 0.6628 - acc: 0.6000 - val_loss: 1.8446 - val_acc: 0.5000 Epoch 6/100 70/70 - 12s - loss: 0.6621 - acc: 0.6071 - val_loss: 1.9661 - val_acc: 0.5000 Epoch 7/100 70/70 - 12s - loss: 0.6346 - acc: 0.6571 - val_loss: 2.8997 - val_acc: 0.5000 Epoch 8/100 70/70 - 12s - loss: 0.6501 - acc: 0.6071 - val_loss: 1.6101 - val_acc: 0.5000 Epoch 9/100 70/70 - 12s - loss: 0.6065 - acc: 0.6571 - val_loss: 0.8688 - val_acc: 0.6167 Epoch 10/100 70/70 - 12s - loss: 0.5970 - acc: 0.6714 - val_loss: 0.8802 - val_acc: 0.5167 Epoch 11/100 70/70 - 12s - loss: 0.5910 - acc: 0.7143 - val_loss: 0.7282 - val_acc: 0.6333 Epoch 12/100 70/70 - 12s - loss: 0.6147 - acc: 0.6500 - val_loss: 0.5828 - val_acc: 0.7500 Epoch 13/100 70/70 - 12s - loss: 0.5641 - acc: 0.7214 - val_loss: 0.7080 - val_acc: 0.6667 Epoch 14/100 70/70 - 12s - loss: 0.5664 - acc: 0.6857 - val_loss: 0.5641 - val_acc: 0.7000 Epoch 15/100 70/70 - 12s - loss: 0.5924 - acc: 0.6929 - val_loss: 0.7595 - val_acc: 0.6000 Epoch 16/100 70/70 - 12s - loss: 0.5389 - acc: 0.7071 - val_loss: 0.5719 - val_acc: 0.7833 Epoch 17/100 70/70 - 12s - loss: 0.5493 - acc: 0.6714 - val_loss: 0.5234 - val_acc: 0.7500 Epoch 18/100 70/70 - 12s - loss: 0.5050 - acc: 0.7786 - val_loss: 0.7359 - val_acc: 0.6000 Epoch 19/100 70/70 - 12s - loss: 0.5152 - acc: 0.7286 - val_loss: 0.6469 - val_acc: 0.6500 Epoch 20/100 70/70 - 12s - loss: 0.5015 - acc: 0.7786 - val_loss: 0.5651 - val_acc: 0.7333 Epoch 21/100 70/70 - 12s - loss: 0.4975 - acc: 0.7786 - val_loss: 0.8707 - val_acc: 0.5500 Epoch 22/100 70/70 - 12s - loss: 0.4470 - acc: 0.7714 - val_loss: 0.5577 - val_acc: 0.7500 Epoch 23/100 70/70 - 12s - loss: 0.5489 - acc: 0.7071 - val_loss: 0.9929 - val_acc: 0.6500 Epoch 24/100 70/70 - 12s - loss: 0.5045 - acc: 0.7357 - val_loss: 0.5891 - val_acc: 0.7333 Epoch 25/100 70/70 - 12s - loss: 0.5598 - acc: 0.7500 - val_loss: 0.5703 - val_acc: 0.7667 Epoch 26/100 70/70 - 12s - loss: 0.4822 - acc: 0.7429 - val_loss: 0.5631 - val_acc: 0.7333 Epoch 27/100 70/70 - 12s - loss: 0.5572 - acc: 0.7000 - val_loss: 0.6255 - val_acc: 0.6500 Epoch 28/100 70/70 - 12s - loss: 0.4694 - acc: 0.7643 - val_loss: 0.7007 - val_acc: 0.6833 Epoch 29/100 70/70 - 12s - loss: 0.4870 - acc: 0.7571 - val_loss: 1.7148 - val_acc: 0.5667 Epoch 30/100 70/70 - 12s - loss: 0.4794 - acc: 0.7500 - val_loss: 0.5744 - val_acc: 0.7333 Epoch 31/100 70/70 - 12s - loss: 0.4632 - acc: 0.7857 - val_loss: 0.7787 - val_acc: 0.5833 It is important to note that the number of samples is very small (only 200) and we don't specify a random seed. As such, you can expect significant variance in the results. The full dataset which consists of over 1000 CT scans can be found here. Using the full dataset, an accuracy of 83% was achieved. A variability of 6-7% in the classification performance is observed in both cases. Visualizing model performance Here the model accuracy and loss for the training and the validation sets are plotted. Since the validation set is class-balanced, accuracy provides an unbiased representation of the model's performance. fig, ax = plt.subplots(1, 2, figsize=(20, 3)) ax = ax.ravel() for i, metric in enumerate([\"acc\", \"loss\"]): ax[i].plot(model.history.history[metric]) ax[i].plot(model.history.history[\"val_\" + metric]) ax[i].set_title(\"Model {}\".format(metric)) ax[i].set_xlabel(\"epochs\") ax[i].set_ylabel(metric) ax[i].legend([\"train\", \"val\"]) png Make predictions on a single CT scan # Load best weights. model.load_weights(\"3d_image_classification.h5\") prediction = model.predict(np.expand_dims(x_val[0], axis=0))[0] scores = [1 - prediction[0], prediction[0]] class_names = [\"normal\", \"abnormal\"] for score, name in zip(scores, class_names): print( \"This model is %.2f percent confident that CT scan is %s\" % ((100 * score), name) ) This model is 26.60 percent confident that CT scan is normal This model is 73.40 percent confident that CT scan is abnormal Minimal implementation of volumetric rendering as shown in NeRF. Introduction In this example, we present a minimal implementation of the research paper NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis by Ben Mildenhall et. al. The authors have proposed an ingenious way to synthesize novel views of a scene by modelling the volumetric scene function through a neural network. To help you understand this intuitively, let's start with the following question: would it be possible to give to a neural network the position of a pixel in an image, and ask the network to predict the color at that position? 2d-train Figure 1: A neural network being given coordinates of an image as input and asked to predict the color at the coordinates. The neural network would hypothetically memorize (overfit on) the image. This means that our neural network would have encoded the entire image in its weights. We could query the neural network with each position, and it would eventually reconstruct the entire image. 2d-test Figure 2: The trained neural network recreates the image from scratch. A question now arises, how do we extend this idea to learn a 3D volumetric scene? Implementing a similar process as above would require the knowledge of every voxel (volume pixel). Turns out, this is quite a challenging task to do. The authors of the paper propose a minimal and elegant way to learn a 3D scene using a few images of the scene. They discard the use of voxels for training. The network learns to model the volumetric scene, thus generating novel views (images) of the 3D scene that the model was not shown at training time. There are a few prerequisites one needs to understand to fully appreciate the process. We structure the example in such a way that you will have all the required knowledge before starting the implementation. Setup # Setting random seed to obtain reproducible results. import tensorflow as tf tf.random.set_seed(42) import os import glob import imageio import numpy as np from tqdm import tqdm from tensorflow import keras from tensorflow.keras import layers import matplotlib.pyplot as plt # Initialize global variables. AUTO = tf.data.AUTOTUNE BATCH_SIZE = 5 NUM_SAMPLES = 32 POS_ENCODE_DIMS = 16 EPOCHS = 20 Download and load the data The npz data file contains images, camera poses, and a focal length. The images are taken from multiple camera angles as shown in Figure 3. camera-angles Figure 3: Multiple camera angles Source: NeRF To understand camera poses in this context we have to first allow ourselves to think that a camera is a mapping between the real-world and the 2-D image. mapping Figure 4: 3-D world to 2-D image mapping through a camera Source: Mathworks Consider the following equation: Where x is the 2-D image point, X is the 3-D world point and P is the camera-matrix. P is a 3 x 4 matrix that plays the crucial role of mapping the real world object onto an image plane. The camera-matrix is an affine transform matrix that is concatenated with a 3 x 1 column [image height, image width, focal length] to produce the pose matrix. This matrix is of dimensions 3 x 5 where the first 3 x 3 block is in the camera’s point of view. The axes are [down, right, backwards] or [-y, x, z] where the camera is facing forwards -z. camera-mapping Figure 5: The affine transformation. The COLMAP frame is [right, down, forwards] or [x, -y, -z]. Read more about COLMAP here. # Download the data if it does not already exist. file_name = \"tiny_nerf_data.npz\" url = \"https://people.eecs.berkeley.edu/~bmild/nerf/tiny_nerf_data.npz\" if not os.path.exists(file_name): data = keras.utils.get_file(fname=file_name, origin=url) data = np.load(data) images = data[\"images\"] im_shape = images.shape (num_images, H, W, _) = images.shape (poses, focal) = (data[\"poses\"], data[\"focal\"]) # Plot a random image from the dataset for visualization. plt.imshow(images[np.random.randint(low=0, high=num_images)]) plt.show() Downloading data from https://people.eecs.berkeley.edu/~bmild/nerf/tiny_nerf_data.npz 12730368/12727482 [==============================] - 0s 0us/step png Data pipeline Now that you've understood the notion of camera matrix and the mapping from a 3D scene to 2D images, let's talk about the inverse mapping, i.e. from 2D image to the 3D scene. We'll need to talk about volumetric rendering with ray casting and tracing, which are common computer graphics techniques. This section will help you get to speed with these techniques. Consider an image with N pixels. We shoot a ray through each pixel and sample some points on the ray. A ray is commonly parameterized by the equation r(t) = o + td where t is the parameter, o is the origin and d is the unit directional vector as shown in Figure 6. img Figure 6: r(t) = o + td where t is 3 In Figure 7, we consider a ray, and we sample some random points on the ray. These sample points each have a unique location (x, y, z) and the ray has a viewing angle (theta, phi). The viewing angle is particularly interesting as we can shoot a ray through a single pixel in a lot of different ways, each with a unique viewing angle. Another interesting thing to notice here is the noise that is added to the sampling process. We add a uniform noise to each sample so that the samples correspond to a continuous distribution. In Figure 7 the blue points are the evenly distributed samples and the white points (t1, t2, t3) are randomly placed between the samples. img Figure 7: Sampling the points from a ray. Figure 8 showcases the entire sampling process in 3D, where you can see the rays coming out of the white image. This means that each pixel will have its corresponding rays and each ray will be sampled at distinct points. 3-d rays Figure 8: Shooting rays from all the pixels of an image in 3-D These sampled points act as the input to the NeRF model. The model is then asked to predict the RGB color and the volume density at that point. 3-Drender Figure 9: Data pipeline Source: NeRF def encode_position(x): \"\"\"Encodes the position into its corresponding Fourier feature. Args: x: The input coordinate. Returns: Fourier features tensors of the position. \"\"\" positions = [x] for i in range(POS_ENCODE_DIMS): for fn in [tf.sin, tf.cos]: positions.append(fn(2.0 ** i * x)) return tf.concat(positions, axis=-1) def get_rays(height, width, focal, pose): \"\"\"Computes origin point and direction vector of rays. Args: height: Height of the image. width: Width of the image. focal: The focal length between the images and the camera. pose: The pose matrix of the camera. Returns: Tuple of origin point and direction vector for rays. \"\"\" # Build a meshgrid for the rays. i, j = tf.meshgrid( tf.range(width, dtype=tf.float32), tf.range(height, dtype=tf.float32), indexing=\"xy\", ) # Normalize the x axis coordinates. transformed_i = (i - width * 0.5) / focal # Normalize the y axis coordinates. transformed_j = (j - height * 0.5) / focal # Create the direction unit vectors. directions = tf.stack([transformed_i, -transformed_j, -tf.ones_like(i)], axis=-1) # Get the camera matrix. camera_matrix = pose[:3, :3] height_width_focal = pose[:3, -1] # Get origins and directions for the rays. transformed_dirs = directions[..., None, :] camera_dirs = transformed_dirs * camera_matrix ray_directions = tf.reduce_sum(camera_dirs, axis=-1) ray_origins = tf.broadcast_to(height_width_focal, tf.shape(ray_directions)) # Return the origins and directions. return (ray_origins, ray_directions) def render_flat_rays(ray_origins, ray_directions, near, far, num_samples, rand=False): \"\"\"Renders the rays and flattens it. Args: ray_origins: The origin points for rays. ray_directions: The direction unit vectors for the rays. near: The near bound of the volumetric scene. far: The far bound of the volumetric scene. num_samples: Number of sample points in a ray. rand: Choice for randomising the sampling strategy. Returns: Tuple of flattened rays and sample points on each rays. \"\"\" # Compute 3D query points. # Equation: r(t) = o+td -> Building the \"t\" here. t_vals = tf.linspace(near, far, num_samples) if rand: # Inject uniform noise into sample space to make the sampling # continuous. shape = list(ray_origins.shape[:-1]) + [num_samples] noise = tf.random.uniform(shape=shape) * (far - near) / num_samples t_vals = t_vals + noise # Equation: r(t) = o + td -> Building the \"r\" here. rays = ray_origins[..., None, :] + ( ray_directions[..., None, :] * t_vals[..., None] ) rays_flat = tf.reshape(rays, [-1, 3]) rays_flat = encode_position(rays_flat) return (rays_flat, t_vals) def map_fn(pose): \"\"\"Maps individual pose to flattened rays and sample points. Args: pose: The pose matrix of the camera. Returns: Tuple of flattened rays and sample points corresponding to the camera pose. \"\"\" (ray_origins, ray_directions) = get_rays(height=H, width=W, focal=focal, pose=pose) (rays_flat, t_vals) = render_flat_rays( ray_origins=ray_origins, ray_directions=ray_directions, near=2.0, far=6.0, num_samples=NUM_SAMPLES, rand=True, ) return (rays_flat, t_vals) # Create the training split. split_index = int(num_images * 0.8) # Split the images into training and validation. train_images = images[:split_index] val_images = images[split_index:] # Split the poses into training and validation. train_poses = poses[:split_index] val_poses = poses[split_index:] # Make the training pipeline. train_img_ds = tf.data.Dataset.from_tensor_slices(train_images) train_pose_ds = tf.data.Dataset.from_tensor_slices(train_poses) train_ray_ds = train_pose_ds.map(map_fn, num_parallel_calls=AUTO) training_ds = tf.data.Dataset.zip((train_img_ds, train_ray_ds)) train_ds = ( training_ds.shuffle(BATCH_SIZE) .batch(BATCH_SIZE, drop_remainder=True, num_parallel_calls=AUTO) .prefetch(AUTO) ) # Make the validation pipeline. val_img_ds = tf.data.Dataset.from_tensor_slices(val_images) val_pose_ds = tf.data.Dataset.from_tensor_slices(val_poses) val_ray_ds = val_pose_ds.map(map_fn, num_parallel_calls=AUTO) validation_ds = tf.data.Dataset.zip((val_img_ds, val_ray_ds)) val_ds = ( validation_ds.shuffle(BATCH_SIZE) .batch(BATCH_SIZE, drop_remainder=True, num_parallel_calls=AUTO) .prefetch(AUTO) ) NeRF model The model is a multi-layer perceptron (MLP), with ReLU as its non-linearity. An excerpt from the paper: \"We encourage the representation to be multiview-consistent by restricting the network to predict the volume density sigma as a function of only the location x, while allowing the RGB color c to be predicted as a function of both location and viewing direction. To accomplish this, the MLP first processes the input 3D coordinate x with 8 fully-connected layers (using ReLU activations and 256 channels per layer), and outputs sigma and a 256-dimensional feature vector. This feature vector is then concatenated with the camera ray's viewing direction and passed to one additional fully-connected layer (using a ReLU activation and 128 channels) that output the view-dependent RGB color.\" Here we have gone for a minimal implementation and have used 64 Dense units instead of 256 as mentioned in the paper. def get_nerf_model(num_layers, num_pos): \"\"\"Generates the NeRF neural network. Args: num_layers: The number of MLP layers. num_pos: The number of dimensions of positional encoding. Returns: The [`tf.keras`](https://www.tensorflow.org/api_docs/python/tf/keras) model. \"\"\" inputs = keras.Input(shape=(num_pos, 2 * 3 * POS_ENCODE_DIMS + 3)) x = inputs for i in range(num_layers): x = layers.Dense(units=64, activation=\"relu\")(x) if i % 4 == 0 and i > 0: # Inject residual connection. x = layers.concatenate([x, inputs], axis=-1) outputs = layers.Dense(units=4)(x) return keras.Model(inputs=inputs, outputs=outputs) def render_rgb_depth(model, rays_flat, t_vals, rand=True, train=True): \"\"\"Generates the RGB image and depth map from model prediction. Args: model: The MLP model that is trained to predict the rgb and volume density of the volumetric scene. rays_flat: The flattened rays that serve as the input to the NeRF model. t_vals: The sample points for the rays. rand: Choice to randomise the sampling strategy. train: Whether the model is in the training or testing phase. Returns: Tuple of rgb image and depth map. \"\"\" # Get the predictions from the nerf model and reshape it. if train: predictions = model(rays_flat) else: predictions = model.predict(rays_flat) predictions = tf.reshape(predictions, shape=(BATCH_SIZE, H, W, NUM_SAMPLES, 4)) # Slice the predictions into rgb and sigma. rgb = tf.sigmoid(predictions[..., :-1]) sigma_a = tf.nn.relu(predictions[..., -1]) # Get the distance of adjacent intervals. delta = t_vals[..., 1:] - t_vals[..., :-1] # delta shape = (num_samples) if rand: delta = tf.concat( [delta, tf.broadcast_to([1e10], shape=(BATCH_SIZE, H, W, 1))], axis=-1 ) alpha = 1.0 - tf.exp(-sigma_a * delta) else: delta = tf.concat( [delta, tf.broadcast_to([1e10], shape=(BATCH_SIZE, 1))], axis=-1 ) alpha = 1.0 - tf.exp(-sigma_a * delta[:, None, None, :]) # Get transmittance. exp_term = 1.0 - alpha epsilon = 1e-10 transmittance = tf.math.cumprod(exp_term + epsilon, axis=-1, exclusive=True) weights = alpha * transmittance rgb = tf.reduce_sum(weights[..., None] * rgb, axis=-2) if rand: depth_map = tf.reduce_sum(weights * t_vals, axis=-1) else: depth_map = tf.reduce_sum(weights * t_vals[:, None, None], axis=-1) return (rgb, depth_map) Training The training step is implemented as part of a custom keras.Model subclass so that we can make use of the model.fit functionality. class NeRF(keras.Model): def __init__(self, nerf_model): super().__init__() self.nerf_model = nerf_model def compile(self, optimizer, loss_fn): super().compile() self.optimizer = optimizer self.loss_fn = loss_fn self.loss_tracker = keras.metrics.Mean(name=\"loss\") self.psnr_metric = keras.metrics.Mean(name=\"psnr\") def train_step(self, inputs): # Get the images and the rays. (images, rays) = inputs (rays_flat, t_vals) = rays with tf.GradientTape() as tape: # Get the predictions from the model. rgb, _ = render_rgb_depth( model=self.nerf_model, rays_flat=rays_flat, t_vals=t_vals, rand=True ) loss = self.loss_fn(images, rgb) # Get the trainable variables. trainable_variables = self.nerf_model.trainable_variables # Get the gradeints of the trainiable variables with respect to the loss. gradients = tape.gradient(loss, trainable_variables) # Apply the grads and optimize the model. self.optimizer.apply_gradients(zip(gradients, trainable_variables)) # Get the PSNR of the reconstructed images and the source images. psnr = tf.image.psnr(images, rgb, max_val=1.0) # Compute our own metrics self.loss_tracker.update_state(loss) self.psnr_metric.update_state(psnr) return {\"loss\": self.loss_tracker.result(), \"psnr\": self.psnr_metric.result()} def test_step(self, inputs): # Get the images and the rays. (images, rays) = inputs (rays_flat, t_vals) = rays # Get the predictions from the model. rgb, _ = render_rgb_depth( model=self.nerf_model, rays_flat=rays_flat, t_vals=t_vals, rand=True ) loss = self.loss_fn(images, rgb) # Get the PSNR of the reconstructed images and the source images. psnr = tf.image.psnr(images, rgb, max_val=1.0) # Compute our own metrics self.loss_tracker.update_state(loss) self.psnr_metric.update_state(psnr) return {\"loss\": self.loss_tracker.result(), \"psnr\": self.psnr_metric.result()} @property def metrics(self): return [self.loss_tracker, self.psnr_metric] test_imgs, test_rays = next(iter(train_ds)) test_rays_flat, test_t_vals = test_rays loss_list = [] class TrainMonitor(keras.callbacks.Callback): def on_epoch_end(self, epoch, logs=None): loss = logs[\"loss\"] loss_list.append(loss) test_recons_images, depth_maps = render_rgb_depth( model=self.model.nerf_model, rays_flat=test_rays_flat, t_vals=test_t_vals, rand=True, train=False, ) # Plot the rgb, depth and the loss plot. fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(20, 5)) ax[0].imshow(keras.preprocessing.image.array_to_img(test_recons_images[0])) ax[0].set_title(f\"Predicted Image: {epoch:03d}\") ax[1].imshow(keras.preprocessing.image.array_to_img(depth_maps[0, ..., None])) ax[1].set_title(f\"Depth Map: {epoch:03d}\") ax[2].plot(loss_list) ax[2].set_xticks(np.arange(0, EPOCHS + 1, 5.0)) ax[2].set_title(f\"Loss Plot: {epoch:03d}\") fig.savefig(f\"images/{epoch:03d}.png\") plt.show() plt.close() num_pos = H * W * NUM_SAMPLES nerf_model = get_nerf_model(num_layers=8, num_pos=num_pos) model = NeRF(nerf_model) model.compile( optimizer=keras.optimizers.Adam(), loss_fn=keras.losses.MeanSquaredError() ) # Create a directory to save the images during training. if not os.path.exists(\"images\"): os.makedirs(\"images\") model.fit( train_ds, validation_data=val_ds, batch_size=BATCH_SIZE, epochs=EPOCHS, callbacks=[TrainMonitor()], steps_per_epoch=split_index // BATCH_SIZE, ) def create_gif(path_to_images, name_gif): filenames = glob.glob(path_to_images) filenames = sorted(filenames) images = [] for filename in tqdm(filenames): images.append(imageio.imread(filename)) kargs = {\"duration\": 0.25} imageio.mimsave(name_gif, images, \"GIF\", **kargs) create_gif(\"images/*.png\", \"training.gif\") Epoch 1/20 16/16 [==============================] - 15s 753ms/step - loss: 0.1134 - psnr: 9.7278 - val_loss: 0.0683 - val_psnr: 12.0722 png Epoch 2/20 16/16 [==============================] - 13s 752ms/step - loss: 0.0648 - psnr: 12.4200 - val_loss: 0.0664 - val_psnr: 12.1765 png Epoch 3/20 16/16 [==============================] - 13s 746ms/step - loss: 0.0607 - psnr: 12.5281 - val_loss: 0.0673 - val_psnr: 12.0121 png Epoch 4/20 16/16 [==============================] - 13s 758ms/step - loss: 0.0595 - psnr: 12.7050 - val_loss: 0.0646 - val_psnr: 12.2768 png Epoch 5/20 16/16 [==============================] - 13s 755ms/step - loss: 0.0583 - psnr: 12.7522 - val_loss: 0.0613 - val_psnr: 12.5351 png Epoch 6/20 16/16 [==============================] - 13s 749ms/step - loss: 0.0545 - psnr: 13.0654 - val_loss: 0.0553 - val_psnr: 12.9512 png Epoch 7/20 16/16 [==============================] - 13s 744ms/step - loss: 0.0480 - psnr: 13.6313 - val_loss: 0.0444 - val_psnr: 13.7838 png Epoch 8/20 16/16 [==============================] - 13s 763ms/step - loss: 0.0359 - psnr: 14.8570 - val_loss: 0.0342 - val_psnr: 14.8823 png Epoch 9/20 16/16 [==============================] - 13s 758ms/step - loss: 0.0299 - psnr: 15.5374 - val_loss: 0.0287 - val_psnr: 15.6171 png Epoch 10/20 16/16 [==============================] - 13s 779ms/step - loss: 0.0273 - psnr: 15.9051 - val_loss: 0.0266 - val_psnr: 15.9319 png Epoch 11/20 16/16 [==============================] - 13s 736ms/step - loss: 0.0255 - psnr: 16.1422 - val_loss: 0.0250 - val_psnr: 16.1568 png Epoch 12/20 16/16 [==============================] - 13s 746ms/step - loss: 0.0236 - psnr: 16.5074 - val_loss: 0.0233 - val_psnr: 16.4793 png Epoch 13/20 16/16 [==============================] - 13s 755ms/step - loss: 0.0217 - psnr: 16.8391 - val_loss: 0.0210 - val_psnr: 16.8950 png Epoch 14/20 16/16 [==============================] - 13s 741ms/step - loss: 0.0197 - psnr: 17.2245 - val_loss: 0.0187 - val_psnr: 17.3766 png Epoch 15/20 16/16 [==============================] - 13s 739ms/step - loss: 0.0179 - psnr: 17.6246 - val_loss: 0.0179 - val_psnr: 17.5445 png Epoch 16/20 16/16 [==============================] - 13s 735ms/step - loss: 0.0175 - psnr: 17.6998 - val_loss: 0.0180 - val_psnr: 17.5154 png Epoch 17/20 16/16 [==============================] - 13s 741ms/step - loss: 0.0167 - psnr: 17.9393 - val_loss: 0.0156 - val_psnr: 18.1784 png Epoch 18/20 16/16 [==============================] - 13s 750ms/step - loss: 0.0150 - psnr: 18.3875 - val_loss: 0.0151 - val_psnr: 18.2811 png Epoch 19/20 16/16 [==============================] - 13s 755ms/step - loss: 0.0141 - psnr: 18.6476 - val_loss: 0.0139 - val_psnr: 18.6216 png Epoch 20/20 16/16 [==============================] - 14s 777ms/step - loss: 0.0139 - psnr: 18.7131 - val_loss: 0.0137 - val_psnr: 18.7259 png 100%|██████████| 20/20 [00:00<00:00, 57.59it/s] Visualize the training step Here we see the training step. With the decreasing loss, the rendered image and the depth maps are getting better. In your local system, you will see the training.gif file generated. training-20 Inference In this section, we ask the model to build novel views of the scene. The model was given 106 views of the scene in the training step. The collections of training images cannot contain each and every angle of the scene. A trained model can represent the entire 3-D scene with a sparse set of training images. Here we provide different poses to the model and ask for it to give us the 2-D image corresponding to that camera view. If we infer the model for all the 360-degree views, it should provide an overview of the entire scenery from all around. # Get the trained NeRF model and infer. nerf_model = model.nerf_model test_recons_images, depth_maps = render_rgb_depth( model=nerf_model, rays_flat=test_rays_flat, t_vals=test_t_vals, rand=True, train=False, ) # Create subplots. fig, axes = plt.subplots(nrows=5, ncols=3, figsize=(10, 20)) for ax, ori_img, recons_img, depth_map in zip( axes, test_imgs, test_recons_images, depth_maps ): ax[0].imshow(keras.preprocessing.image.array_to_img(ori_img)) ax[0].set_title(\"Original\") ax[1].imshow(keras.preprocessing.image.array_to_img(recons_img)) ax[1].set_title(\"Reconstructed\") ax[2].imshow( keras.preprocessing.image.array_to_img(depth_map[..., None]), cmap=\"inferno\" ) ax[2].set_title(\"Depth Map\") png Render 3D Scene Here we will synthesize novel 3D views and stitch all of them together to render a video encompassing the 360-degree view. def get_translation_t(t): \"\"\"Get the translation matrix for movement in t.\"\"\" matrix = [ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, t], [0, 0, 0, 1], ] return tf.convert_to_tensor(matrix, dtype=tf.float32) def get_rotation_phi(phi): \"\"\"Get the rotation matrix for movement in phi.\"\"\" matrix = [ [1, 0, 0, 0], [0, tf.cos(phi), -tf.sin(phi), 0], [0, tf.sin(phi), tf.cos(phi), 0], [0, 0, 0, 1], ] return tf.convert_to_tensor(matrix, dtype=tf.float32) def get_rotation_theta(theta): \"\"\"Get the rotation matrix for movement in theta.\"\"\" matrix = [ [tf.cos(theta), 0, -tf.sin(theta), 0], [0, 1, 0, 0], [tf.sin(theta), 0, tf.cos(theta), 0], [0, 0, 0, 1], ] return tf.convert_to_tensor(matrix, dtype=tf.float32) def pose_spherical(theta, phi, t): \"\"\" Get the camera to world matrix for the corresponding theta, phi and t. \"\"\" c2w = get_translation_t(t) c2w = get_rotation_phi(phi / 180.0 * np.pi) @ c2w c2w = get_rotation_theta(theta / 180.0 * np.pi) @ c2w c2w = np.array([[-1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]) @ c2w return c2w rgb_frames = [] batch_flat = [] batch_t = [] # Iterate over different theta value and generate scenes. for index, theta in tqdm(enumerate(np.linspace(0.0, 360.0, 120, endpoint=False))): # Get the camera to world matrix. c2w = pose_spherical(theta, -30.0, 4.0) # ray_oris, ray_dirs = get_rays(H, W, focal, c2w) rays_flat, t_vals = render_flat_rays( ray_oris, ray_dirs, near=2.0, far=6.0, num_samples=NUM_SAMPLES, rand=False ) if index % BATCH_SIZE == 0 and index > 0: batched_flat = tf.stack(batch_flat, axis=0) batch_flat = [rays_flat] batched_t = tf.stack(batch_t, axis=0) batch_t = [t_vals] rgb, _ = render_rgb_depth( nerf_model, batched_flat, batched_t, rand=False, train=False ) temp_rgb = [np.clip(255 * img, 0.0, 255.0).astype(np.uint8) for img in rgb] rgb_frames = rgb_frames + temp_rgb else: batch_flat.append(rays_flat) batch_t.append(t_vals) rgb_video = \"rgb_video.mp4\" imageio.mimwrite(rgb_video, rgb_frames, fps=30, quality=7, macro_block_size=None) 120it [00:12, 9.24it/s] Visualize the video Here we can see the rendered 360 degree view of the scene. The model has successfully learned the entire volumetric space through the sparse set of images in only 20 epochs. You can view the rendered video saved locally, named rgb_video.mp4. rendered-video Conclusion We have produced a minimal implementation of NeRF to provide an intuition of its core ideas and methodology. This method has been used in various other works in the computer graphics space. We would like to encourage our readers to use this code as an example and play with the hyperparameters and visualize the outputs. Below we have also provided the outputs of the model trained for more epochs. Epochs GIF of the training step 100 100-epoch-training 200 200-epoch-training Reference NeRF repository: The official repository for NeRF. NeRF paper: The paper on NeRF. Manim Repository: We have used manim to build all the animations. Mathworks: Mathworks for the camera calibration article. Mathew's video: A great video on NeRF. Compact Convolutional Transformers As discussed in the Vision Transformers (ViT) paper, a Transformer-based architecture for vision typically requires a larger dataset than usual, as well as a longer pre-training schedule. ImageNet-1k (which has about a million images) is considered to fall under the medium-sized data regime with respect to ViTs. This is primarily because, unlike CNNs, ViTs (or a typical Transformer-based architecture) do not have well-informed inductive biases (such as convolutions for processing images). This begs the question: can't we combine the benefits of convolution and the benefits of Transformers in a single network architecture? These benefits include parameter-efficiency, and self-attention to process long-range and global dependencies (interactions between different regions in an image). In Escaping the Big Data Paradigm with Compact Transformers, Hassani et al. present an approach for doing exactly this. They proposed the Compact Convolutional Transformer (CCT) architecture. In this example, we will work on an implementation of CCT and we will see how well it performs on the CIFAR-10 dataset. If you are unfamiliar with the concept of self-attention or Transformers, you can read this chapter from François Chollet's book Deep Learning with Python. This example uses code snippets from another example, Image classification with Vision Transformer. This example requires TensorFlow 2.5 or higher, as well as TensorFlow Addons, which can be installed using the following command: !pip install -U -q tensorflow-addons  |████████████████████████████████| 686kB 5.4MB/s [?25h Imports from tensorflow.keras import layers from tensorflow import keras import matplotlib.pyplot as plt import tensorflow_addons as tfa import tensorflow as tf import numpy as np Hyperparameters and constants positional_emb = True conv_layers = 2 projection_dim = 128 num_heads = 2 transformer_units = [ projection_dim, projection_dim, ] transformer_layers = 2 stochastic_depth_rate = 0.1 learning_rate = 0.001 weight_decay = 0.0001 batch_size = 128 num_epochs = 30 image_size = 32 Load CIFAR-10 dataset num_classes = 10 input_shape = (32, 32, 3) (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\") print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\") Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz 170500096/170498071 [==============================] - 11s 0us/step x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 10) x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 10) The CCT tokenizer The first recipe introduced by the CCT authors is the tokenizer for processing the images. In a standard ViT, images are organized into uniform non-overlapping patches. This eliminates the boundary-level information present in between different patches. This is important for a neural network to effectively exploit the locality information. The figure below presents an illustration of how images are organized into patches. We already know that convolutions are quite good at exploiting locality information. So, based on this, the authors introduce an all-convolution mini-network to produce image patches. class CCTTokenizer(layers.Layer): def __init__( self, kernel_size=3, stride=1, padding=1, pooling_kernel_size=3, pooling_stride=2, num_conv_layers=conv_layers, num_output_channels=[64, 128], positional_emb=positional_emb, **kwargs, ): super(CCTTokenizer, self).__init__(**kwargs) # This is our tokenizer. self.conv_model = keras.Sequential() for i in range(num_conv_layers): self.conv_model.add( layers.Conv2D( num_output_channels[i], kernel_size, stride, padding=\"valid\", use_bias=False, activation=\"relu\", kernel_initializer=\"he_normal\", ) ) self.conv_model.add(layers.ZeroPadding2D(padding)) self.conv_model.add( layers.MaxPool2D(pooling_kernel_size, pooling_stride, \"same\") ) self.positional_emb = positional_emb def call(self, images): outputs = self.conv_model(images) # After passing the images through our mini-network the spatial dimensions # are flattened to form sequences. reshaped = tf.reshape( outputs, (-1, tf.shape(outputs)[1] * tf.shape(outputs)[2], tf.shape(outputs)[-1]), ) return reshaped def positional_embedding(self, image_size): # Positional embeddings are optional in CCT. Here, we calculate # the number of sequences and initialize an `Embedding` layer to # compute the positional embeddings later. if self.positional_emb: dummy_inputs = tf.ones((1, image_size, image_size, 3)) dummy_outputs = self.call(dummy_inputs) sequence_length = tf.shape(dummy_outputs)[1] projection_dim = tf.shape(dummy_outputs)[-1] embed_layer = layers.Embedding( input_dim=sequence_length, output_dim=projection_dim ) return embed_layer, sequence_length else: return None Stochastic depth for regularization Stochastic depth is a regularization technique that randomly drops a set of layers. During inference, the layers are kept as they are. It is very much similar to Dropout but only that it operates on a block of layers rather than individual nodes present inside a layer. In CCT, stochastic depth is used just before the residual blocks of a Transformers encoder. # Referred from: github.com:rwightman/pytorch-image-models. class StochasticDepth(layers.Layer): def __init__(self, drop_prop, **kwargs): super(StochasticDepth, self).__init__(**kwargs) self.drop_prob = drop_prop def call(self, x, training=None): if training: keep_prob = 1 - self.drop_prob shape = (tf.shape(x)[0],) + (1,) * (len(tf.shape(x)) - 1) random_tensor = keep_prob + tf.random.uniform(shape, 0, 1) random_tensor = tf.floor(random_tensor) return (x / keep_prob) * random_tensor return x MLP for the Transformers encoder def mlp(x, hidden_units, dropout_rate): for units in hidden_units: x = layers.Dense(units, activation=tf.nn.gelu)(x) x = layers.Dropout(dropout_rate)(x) return x Data augmentation In the original paper, the authors use AutoAugment to induce stronger regularization. For this example, we will be using the standard geometric augmentations like random cropping and flipping. # Note the rescaling layer. These layers have pre-defined inference behavior. data_augmentation = keras.Sequential( [ layers.Rescaling(scale=1.0 / 255), layers.RandomCrop(image_size, image_size), layers.RandomFlip(\"horizontal\"), ], name=\"data_augmentation\", ) The final CCT model Another recipe introduced in CCT is attention pooling or sequence pooling. In ViT, only the feature map corresponding to the class token is pooled and is then used for the subsequent classification task (or any other downstream task). In CCT, outputs from the Transformers encoder are weighted and then passed on to the final task-specific layer (in this example, we do classification). def create_cct_model( image_size=image_size, input_shape=input_shape, num_heads=num_heads, projection_dim=projection_dim, transformer_units=transformer_units, ): inputs = layers.Input(input_shape) # Augment data. augmented = data_augmentation(inputs) # Encode patches. cct_tokenizer = CCTTokenizer() encoded_patches = cct_tokenizer(augmented) # Apply positional embedding. if positional_emb: pos_embed, seq_length = cct_tokenizer.positional_embedding(image_size) positions = tf.range(start=0, limit=seq_length, delta=1) position_embeddings = pos_embed(positions) encoded_patches += position_embeddings # Calculate Stochastic Depth probabilities. dpr = [x for x in np.linspace(0, stochastic_depth_rate, transformer_layers)] # Create multiple layers of the Transformer block. for i in range(transformer_layers): # Layer normalization 1. x1 = layers.LayerNormalization(epsilon=1e-5)(encoded_patches) # Create a multi-head attention layer. attention_output = layers.MultiHeadAttention( num_heads=num_heads, key_dim=projection_dim, dropout=0.1 )(x1, x1) # Skip connection 1. attention_output = StochasticDepth(dpr[i])(attention_output) x2 = layers.Add()([attention_output, encoded_patches]) # Layer normalization 2. x3 = layers.LayerNormalization(epsilon=1e-5)(x2) # MLP. x3 = mlp(x3, hidden_units=transformer_units, dropout_rate=0.1) # Skip connection 2. x3 = StochasticDepth(dpr[i])(x3) encoded_patches = layers.Add()([x3, x2]) # Apply sequence pooling. representation = layers.LayerNormalization(epsilon=1e-5)(encoded_patches) attention_weights = tf.nn.softmax(layers.Dense(1)(representation), axis=1) weighted_representation = tf.matmul( attention_weights, representation, transpose_a=True ) weighted_representation = tf.squeeze(weighted_representation, -2) # Classify outputs. logits = layers.Dense(num_classes)(weighted_representation) # Create the Keras model. model = keras.Model(inputs=inputs, outputs=logits) return model Model training and evaluation def run_experiment(model): optimizer = tfa.optimizers.AdamW(learning_rate=0.001, weight_decay=0.0001) model.compile( optimizer=optimizer, loss=keras.losses.CategoricalCrossentropy( from_logits=True, label_smoothing=0.1 ), metrics=[ keras.metrics.CategoricalAccuracy(name=\"accuracy\"), keras.metrics.TopKCategoricalAccuracy(5, name=\"top-5-accuracy\"), ], ) checkpoint_filepath = \"/tmp/checkpoint\" checkpoint_callback = keras.callbacks.ModelCheckpoint( checkpoint_filepath, monitor=\"val_accuracy\", save_best_only=True, save_weights_only=True, ) history = model.fit( x=x_train, y=y_train, batch_size=batch_size, epochs=num_epochs, validation_split=0.1, callbacks=[checkpoint_callback], ) model.load_weights(checkpoint_filepath) _, accuracy, top_5_accuracy = model.evaluate(x_test, y_test) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") print(f\"Test top 5 accuracy: {round(top_5_accuracy * 100, 2)}%\") return history cct_model = create_cct_model() history = run_experiment(cct_model) Epoch 1/30 352/352 [==============================] - 10s 18ms/step - loss: 1.9181 - accuracy: 0.3277 - top-5-accuracy: 0.8296 - val_loss: 1.7123 - val_accuracy: 0.4250 - val_top-5-accuracy: 0.9028 Epoch 2/30 352/352 [==============================] - 6s 16ms/step - loss: 1.5725 - accuracy: 0.5010 - top-5-accuracy: 0.9295 - val_loss: 1.5026 - val_accuracy: 0.5530 - val_top-5-accuracy: 0.9364 Epoch 3/30 352/352 [==============================] - 6s 16ms/step - loss: 1.4492 - accuracy: 0.5633 - top-5-accuracy: 0.9476 - val_loss: 1.3744 - val_accuracy: 0.6038 - val_top-5-accuracy: 0.9558 Epoch 4/30 352/352 [==============================] - 6s 16ms/step - loss: 1.3658 - accuracy: 0.6055 - top-5-accuracy: 0.9576 - val_loss: 1.3258 - val_accuracy: 0.6148 - val_top-5-accuracy: 0.9648 Epoch 5/30 352/352 [==============================] - 6s 16ms/step - loss: 1.3142 - accuracy: 0.6302 - top-5-accuracy: 0.9640 - val_loss: 1.2723 - val_accuracy: 0.6468 - val_top-5-accuracy: 0.9710 Epoch 6/30 352/352 [==============================] - 6s 16ms/step - loss: 1.2729 - accuracy: 0.6489 - top-5-accuracy: 0.9684 - val_loss: 1.2490 - val_accuracy: 0.6640 - val_top-5-accuracy: 0.9704 Epoch 7/30 352/352 [==============================] - 6s 16ms/step - loss: 1.2371 - accuracy: 0.6664 - top-5-accuracy: 0.9711 - val_loss: 1.1822 - val_accuracy: 0.6906 - val_top-5-accuracy: 0.9744 Epoch 8/30 352/352 [==============================] - 6s 16ms/step - loss: 1.1899 - accuracy: 0.6942 - top-5-accuracy: 0.9735 - val_loss: 1.1799 - val_accuracy: 0.6982 - val_top-5-accuracy: 0.9768 Epoch 9/30 352/352 [==============================] - 6s 16ms/step - loss: 1.1706 - accuracy: 0.6972 - top-5-accuracy: 0.9767 - val_loss: 1.1390 - val_accuracy: 0.7148 - val_top-5-accuracy: 0.9768 Epoch 10/30 352/352 [==============================] - 6s 16ms/step - loss: 1.1524 - accuracy: 0.7054 - top-5-accuracy: 0.9783 - val_loss: 1.1803 - val_accuracy: 0.7000 - val_top-5-accuracy: 0.9740 Epoch 11/30 352/352 [==============================] - 6s 16ms/step - loss: 1.1219 - accuracy: 0.7222 - top-5-accuracy: 0.9798 - val_loss: 1.1066 - val_accuracy: 0.7254 - val_top-5-accuracy: 0.9812 Epoch 12/30 352/352 [==============================] - 6s 16ms/step - loss: 1.1029 - accuracy: 0.7287 - top-5-accuracy: 0.9811 - val_loss: 1.0844 - val_accuracy: 0.7388 - val_top-5-accuracy: 0.9814 Epoch 13/30 352/352 [==============================] - 6s 16ms/step - loss: 1.0841 - accuracy: 0.7380 - top-5-accuracy: 0.9825 - val_loss: 1.1159 - val_accuracy: 0.7280 - val_top-5-accuracy: 0.9792 Epoch 14/30 352/352 [==============================] - 6s 16ms/step - loss: 1.0677 - accuracy: 0.7462 - top-5-accuracy: 0.9832 - val_loss: 1.0862 - val_accuracy: 0.7444 - val_top-5-accuracy: 0.9834 Epoch 15/30 352/352 [==============================] - 6s 16ms/step - loss: 1.0511 - accuracy: 0.7535 - top-5-accuracy: 0.9846 - val_loss: 1.0613 - val_accuracy: 0.7494 - val_top-5-accuracy: 0.9832 Epoch 16/30 352/352 [==============================] - 6s 16ms/step - loss: 1.0377 - accuracy: 0.7608 - top-5-accuracy: 0.9854 - val_loss: 1.0379 - val_accuracy: 0.7606 - val_top-5-accuracy: 0.9834 Epoch 17/30 352/352 [==============================] - 6s 16ms/step - loss: 1.0304 - accuracy: 0.7650 - top-5-accuracy: 0.9849 - val_loss: 1.0602 - val_accuracy: 0.7562 - val_top-5-accuracy: 0.9814 Epoch 18/30 352/352 [==============================] - 6s 16ms/step - loss: 1.0121 - accuracy: 0.7746 - top-5-accuracy: 0.9869 - val_loss: 1.0430 - val_accuracy: 0.7630 - val_top-5-accuracy: 0.9834 Epoch 19/30 352/352 [==============================] - 6s 16ms/step - loss: 1.0037 - accuracy: 0.7760 - top-5-accuracy: 0.9872 - val_loss: 1.0951 - val_accuracy: 0.7460 - val_top-5-accuracy: 0.9826 Epoch 20/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9964 - accuracy: 0.7805 - top-5-accuracy: 0.9871 - val_loss: 1.0683 - val_accuracy: 0.7538 - val_top-5-accuracy: 0.9834 Epoch 21/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9838 - accuracy: 0.7850 - top-5-accuracy: 0.9886 - val_loss: 1.0185 - val_accuracy: 0.7770 - val_top-5-accuracy: 0.9876 Epoch 22/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9742 - accuracy: 0.7904 - top-5-accuracy: 0.9894 - val_loss: 1.0253 - val_accuracy: 0.7738 - val_top-5-accuracy: 0.9838 Epoch 23/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9662 - accuracy: 0.7935 - top-5-accuracy: 0.9889 - val_loss: 1.0107 - val_accuracy: 0.7786 - val_top-5-accuracy: 0.9860 Epoch 24/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9549 - accuracy: 0.7994 - top-5-accuracy: 0.9897 - val_loss: 1.0089 - val_accuracy: 0.7790 - val_top-5-accuracy: 0.9852 Epoch 25/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9522 - accuracy: 0.8018 - top-5-accuracy: 0.9896 - val_loss: 1.0214 - val_accuracy: 0.7780 - val_top-5-accuracy: 0.9866 Epoch 26/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9469 - accuracy: 0.8023 - top-5-accuracy: 0.9897 - val_loss: 0.9993 - val_accuracy: 0.7816 - val_top-5-accuracy: 0.9882 Epoch 27/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9463 - accuracy: 0.8022 - top-5-accuracy: 0.9906 - val_loss: 1.0071 - val_accuracy: 0.7848 - val_top-5-accuracy: 0.9850 Epoch 28/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9336 - accuracy: 0.8077 - top-5-accuracy: 0.9909 - val_loss: 1.0113 - val_accuracy: 0.7868 - val_top-5-accuracy: 0.9856 Epoch 29/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9352 - accuracy: 0.8071 - top-5-accuracy: 0.9909 - val_loss: 1.0073 - val_accuracy: 0.7856 - val_top-5-accuracy: 0.9830 Epoch 30/30 352/352 [==============================] - 6s 16ms/step - loss: 0.9273 - accuracy: 0.8112 - top-5-accuracy: 0.9908 - val_loss: 1.0144 - val_accuracy: 0.7792 - val_top-5-accuracy: 0.9836 313/313 [==============================] - 2s 6ms/step - loss: 1.0396 - accuracy: 0.7676 - top-5-accuracy: 0.9839 Test accuracy: 76.76% Test top 5 accuracy: 98.39% Let's now visualize the training progress of the model. plt.plot(history.history[\"loss\"], label=\"train_loss\") plt.plot(history.history[\"val_loss\"], label=\"val_loss\") plt.xlabel(\"Epochs\") plt.ylabel(\"Loss\") plt.title(\"Train and Validation Losses Over Epochs\", fontsize=14) plt.legend() plt.grid() plt.show() png The CCT model we just trained has just 0.4 million parameters, and it gets us to ~78% top-1 accuracy within 30 epochs. The plot above shows no signs of overfitting as well. This means we can train this network for longer (perhaps with a bit more regularization) and may obtain even better performance. This performance can further be improved by additional recipes like cosine decay learning rate schedule, other data augmentation techniques like AutoAugment, MixUp or Cutmix. With these modifications, the authors present 95.1% top-1 accuracy on the CIFAR-10 dataset. The authors also present a number of experiments to study how the number of convolution blocks, Transformers layers, etc. affect the final performance of CCTs. For a comparison, a ViT model takes about 4.7 million parameters and 100 epochs of training to reach a top-1 accuracy of 78.22% on the CIFAR-10 dataset. You can refer to this notebook to know about the experimental setup. The authors also demonstrate the performance of Compact Convolutional Transformers on NLP tasks and they report competitive results there. Training with consistency regularization for robustness against data distribution shifts. Deep learning models excel in many image recognition tasks when the data is independent and identically distributed (i.i.d.). However, they can suffer from performance degradation caused by subtle distribution shifts in the input data (such as random noise, contrast change, and blurring). So, naturally, there arises a question of why. As discussed in A Fourier Perspective on Model Robustness in Computer Vision), there's no reason for deep learning models to be robust against such shifts. Standard model training procedures (such as standard image classification training workflows) don't enable a model to learn beyond what's fed to it in the form of training data. In this example, we will be training an image classification model enforcing a sense of consistency inside it by doing the following: Train a standard image classification model. Train an equal or larger model on a noisy version of the dataset (augmented using RandAugment). To do this, we will first obtain predictions of the previous model on the clean images of the dataset. We will then use these predictions and train the second model to match these predictions on the noisy variant of the same images. This is identical to the workflow of Knowledge Distillation but since the student model is equal or larger in size this process is also referred to as Self-Training. This overall training workflow finds its roots in works like FixMatch, Unsupervised Data Augmentation for Consistency Training, and Noisy Student Training. Since this training process encourages a model yield consistent predictions for clean as well as noisy images, it's often referred to as consistency training or training with consistency regularization. Although the example focuses on using consistency training to enhance the robustness of models to common corruptions this example can also serve a template for performing weakly supervised learning. This example requires TensorFlow 2.4 or higher, as well as TensorFlow Hub and TensorFlow Models, which can be installed using the following command: !pip install -q tf-models-official tensorflow-addons Imports and setup from official.vision.image_classification.augment import RandAugment from tensorflow.keras import layers import tensorflow as tf import tensorflow_addons as tfa import matplotlib.pyplot as plt tf.random.set_seed(42) Define hyperparameters AUTO = tf.data.AUTOTUNE BATCH_SIZE = 128 EPOCHS = 5 CROP_TO = 72 RESIZE_TO = 96 Load the CIFAR-10 dataset (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data() val_samples = 49500 new_train_x, new_y_train = x_train[: val_samples + 1], y_train[: val_samples + 1] val_x, val_y = x_train[val_samples:], y_train[val_samples:] Create TensorFlow Dataset objects # Initialize `RandAugment` object with 2 layers of # augmentation transforms and strength of 9. augmenter = RandAugment(num_layers=2, magnitude=9) For training the teacher model, we will only be using two geometric augmentation transforms: random horizontal flip and random crop. def preprocess_train(image, label, noisy=True): image = tf.image.random_flip_left_right(image) # We first resize the original image to a larger dimension # and then we take random crops from it. image = tf.image.resize(image, [RESIZE_TO, RESIZE_TO]) image = tf.image.random_crop(image, [CROP_TO, CROP_TO, 3]) if noisy: image = augmenter.distort(image) return image, label def preprocess_test(image, label): image = tf.image.resize(image, [CROP_TO, CROP_TO]) return image, label train_ds = tf.data.Dataset.from_tensor_slices((new_train_x, new_y_train)) validation_ds = tf.data.Dataset.from_tensor_slices((val_x, val_y)) test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)) We make sure train_clean_ds and train_noisy_ds are shuffled using the same seed to ensure their orders are exactly the same. This will be helpful during training the student model. # This dataset will be used to train the first model. train_clean_ds = ( train_ds.shuffle(BATCH_SIZE * 10, seed=42) .map(lambda x, y: (preprocess_train(x, y, noisy=False)), num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) # This prepares the `Dataset` object to use RandAugment. train_noisy_ds = ( train_ds.shuffle(BATCH_SIZE * 10, seed=42) .map(preprocess_train, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) validation_ds = ( validation_ds.map(preprocess_test, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) test_ds = ( test_ds.map(preprocess_test, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) # This dataset will be used to train the second model. consistency_training_ds = tf.data.Dataset.zip((train_clean_ds, train_noisy_ds)) Visualize the datasets sample_images, sample_labels = next(iter(train_clean_ds)) plt.figure(figsize=(10, 10)) for i, image in enumerate(sample_images[:9]): ax = plt.subplot(3, 3, i + 1) plt.imshow(image.numpy().astype(\"int\")) plt.axis(\"off\") sample_images, sample_labels = next(iter(train_noisy_ds)) plt.figure(figsize=(10, 10)) for i, image in enumerate(sample_images[:9]): ax = plt.subplot(3, 3, i + 1) plt.imshow(image.numpy().astype(\"int\")) plt.axis(\"off\") png png Define a model building utility function We now define our model building utility. Our model is based on the ResNet50V2 architecture. def get_training_model(num_classes=10): resnet50_v2 = tf.keras.applications.ResNet50V2( weights=None, include_top=False, input_shape=(CROP_TO, CROP_TO, 3), ) model = tf.keras.Sequential( [ layers.Input((CROP_TO, CROP_TO, 3)), layers.Rescaling(scale=1.0 / 127.5, offset=-1), resnet50_v2, layers.GlobalAveragePooling2D(), layers.Dense(num_classes), ] ) return model In the interest of reproducibility, we serialize the initial random weights of the teacher network. initial_teacher_model = get_training_model() initial_teacher_model.save_weights(\"initial_teacher_model.h5\") Train the teacher model As noted in Noisy Student Training, if the teacher model is trained with geometric ensembling and when the student model is forced to mimic that, it leads to better performance. The original work uses Stochastic Depth and Dropout to bring in the ensembling part but for this example, we will use Stochastic Weight Averaging (SWA) which also resembles geometric ensembling. # Define the callbacks. reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(patience=3) early_stopping = tf.keras.callbacks.EarlyStopping( patience=10, restore_best_weights=True ) # Initialize SWA from tf-hub. SWA = tfa.optimizers.SWA # Compile and train the teacher model. teacher_model = get_training_model() teacher_model.load_weights(\"initial_teacher_model.h5\") teacher_model.compile( # Notice that we are wrapping our optimizer within SWA optimizer=SWA(tf.keras.optimizers.Adam()), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[\"accuracy\"], ) history = teacher_model.fit( train_clean_ds, epochs=EPOCHS, validation_data=validation_ds, callbacks=[reduce_lr, early_stopping], ) # Evaluate the teacher model on the test set. _, acc = teacher_model.evaluate(test_ds, verbose=0) print(f\"Test accuracy: {acc*100}%\") Epoch 1/5 387/387 [==============================] - 73s 78ms/step - loss: 1.7785 - accuracy: 0.3582 - val_loss: 2.0589 - val_accuracy: 0.3920 Epoch 2/5 387/387 [==============================] - 28s 71ms/step - loss: 1.2493 - accuracy: 0.5542 - val_loss: 1.4228 - val_accuracy: 0.5380 Epoch 3/5 387/387 [==============================] - 28s 73ms/step - loss: 1.0294 - accuracy: 0.6350 - val_loss: 1.4422 - val_accuracy: 0.5900 Epoch 4/5 387/387 [==============================] - 28s 73ms/step - loss: 0.8954 - accuracy: 0.6864 - val_loss: 1.2189 - val_accuracy: 0.6520 Epoch 5/5 387/387 [==============================] - 28s 73ms/step - loss: 0.7879 - accuracy: 0.7231 - val_loss: 0.9790 - val_accuracy: 0.6500 Test accuracy: 65.83999991416931% Define a self-training utility For this part, we will borrow the Distiller class from this Keras Example. # Majority of the code is taken from: # https://keras.io/examples/vision/knowledge_distillation/ class SelfTrainer(tf.keras.Model): def __init__(self, student, teacher): super(SelfTrainer, self).__init__() self.student = student self.teacher = teacher def compile( self, optimizer, metrics, student_loss_fn, distillation_loss_fn, temperature=3, ): super(SelfTrainer, self).compile(optimizer=optimizer, metrics=metrics) self.student_loss_fn = student_loss_fn self.distillation_loss_fn = distillation_loss_fn self.temperature = temperature def train_step(self, data): # Since our dataset is a zip of two independent datasets, # after initially parsing them, we segregate the # respective images and labels next. clean_ds, noisy_ds = data clean_images, _ = clean_ds noisy_images, y = noisy_ds # Forward pass of teacher teacher_predictions = self.teacher(clean_images, training=False) with tf.GradientTape() as tape: # Forward pass of student student_predictions = self.student(noisy_images, training=True) # Compute losses student_loss = self.student_loss_fn(y, student_predictions) distillation_loss = self.distillation_loss_fn( tf.nn.softmax(teacher_predictions / self.temperature, axis=1), tf.nn.softmax(student_predictions / self.temperature, axis=1), ) total_loss = (student_loss + distillation_loss) / 2 # Compute gradients trainable_vars = self.student.trainable_variables gradients = tape.gradient(total_loss, trainable_vars) # Update weights self.optimizer.apply_gradients(zip(gradients, trainable_vars)) # Update the metrics configured in `compile()` self.compiled_metrics.update_state( y, tf.nn.softmax(student_predictions, axis=1) ) # Return a dict of performance results = {m.name: m.result() for m in self.metrics} results.update({\"total_loss\": total_loss}) return results def test_step(self, data): # During inference, we only pass a dataset consisting images and labels. x, y = data # Compute predictions y_prediction = self.student(x, training=False) # Update the metrics self.compiled_metrics.update_state(y, tf.nn.softmax(y_prediction, axis=1)) # Return a dict of performance results = {m.name: m.result() for m in self.metrics} return results The only difference in this implementation is the way loss is being calculated. Instead of weighted the distillation loss and student loss differently we are taking their average following Noisy Student Training. Train the student model # Define the callbacks. # We are using a larger decay factor to stabilize the training. reduce_lr = tf.keras.callbacks.ReduceLROnPlateau( patience=3, factor=0.5, monitor=\"val_accuracy\" ) early_stopping = tf.keras.callbacks.EarlyStopping( patience=10, restore_best_weights=True, monitor=\"val_accuracy\" ) # Compile and train the student model. self_trainer = SelfTrainer(student=get_training_model(), teacher=teacher_model) self_trainer.compile( # Notice we are *not* using SWA here. optimizer=\"adam\", metrics=[\"accuracy\"], student_loss_fn=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), distillation_loss_fn=tf.keras.losses.KLDivergence(), temperature=10, ) history = self_trainer.fit( consistency_training_ds, epochs=EPOCHS, validation_data=validation_ds, callbacks=[reduce_lr, early_stopping], ) # Evaluate the student model. acc = self_trainer.evaluate(test_ds, verbose=0) print(f\"Test accuracy from student model: {acc*100}%\") Epoch 1/5 387/387 [==============================] - 39s 84ms/step - accuracy: 0.2112 - total_loss: 1.0629 - val_accuracy: 0.4180 Epoch 2/5 387/387 [==============================] - 32s 82ms/step - accuracy: 0.3341 - total_loss: 0.9554 - val_accuracy: 0.3900 Epoch 3/5 387/387 [==============================] - 31s 81ms/step - accuracy: 0.3873 - total_loss: 0.8852 - val_accuracy: 0.4580 Epoch 4/5 387/387 [==============================] - 31s 81ms/step - accuracy: 0.4294 - total_loss: 0.8423 - val_accuracy: 0.5660 Epoch 5/5 387/387 [==============================] - 31s 81ms/step - accuracy: 0.4547 - total_loss: 0.8093 - val_accuracy: 0.5880 Test accuracy from student model: 58.490002155303955% Assess the robustness of the models A standard benchmark of assessing the robustness of vision models is to record their performance on corrupted datasets like ImageNet-C and CIFAR-10-C both of which were proposed in Benchmarking Neural Network Robustness to Common Corruptions and Perturbations. For this example, we will be using the CIFAR-10-C dataset which has 19 different corruptions on 5 different severity levels. To assess the robustness of the models on this dataset, we will do the following: Run the pre-trained models on the highest level of severities and obtain the top-1 accuracies. Compute the mean top-1 accuracy. For the purpose of this example, we won't be going through these steps. This is why we trained the models for only 5 epochs. You can check out this repository that demonstrates the full-scale training experiments and also the aforementioned assessment. The figure below presents an executive summary of that assessment: Mean Top-1 results stand for the CIFAR-10-C dataset and Test Top-1 results stand for the CIFAR-10 test set. It's clear that consistency training has an advantage on not only enhancing the model robustness but also on improving the standard test performance. How to train a deep convolutional autoencoder for image denoising. Introduction This example demonstrates how to implement a deep convolutional autoencoder for image denoising, mapping noisy digits images from the MNIST dataset to clean digits images. This implementation is based on an original blog post titled Building Autoencoders in Keras by François Chollet. Setup import numpy as np import tensorflow as tf import matplotlib.pyplot as plt from tensorflow.keras import layers from tensorflow.keras.datasets import mnist from tensorflow.keras.models import Model def preprocess(array): \"\"\" Normalizes the supplied array and reshapes it into the appropriate format. \"\"\" array = array.astype(\"float32\") / 255.0 array = np.reshape(array, (len(array), 28, 28, 1)) return array def noise(array): \"\"\" Adds random noise to each image in the supplied array. \"\"\" noise_factor = 0.4 noisy_array = array + noise_factor * np.random.normal( loc=0.0, scale=1.0, size=array.shape ) return np.clip(noisy_array, 0.0, 1.0) def display(array1, array2): \"\"\" Displays ten random images from each one of the supplied arrays. \"\"\" n = 10 indices = np.random.randint(len(array1), size=n) images1 = array1[indices, :] images2 = array2[indices, :] plt.figure(figsize=(20, 4)) for i, (image1, image2) in enumerate(zip(images1, images2)): ax = plt.subplot(2, n, i + 1) plt.imshow(image1.reshape(28, 28)) plt.gray() ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax = plt.subplot(2, n, i + 1 + n) plt.imshow(image2.reshape(28, 28)) plt.gray() ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) plt.show() Prepare the data # Since we only need images from the dataset to encode and decode, we # won't use the labels. (train_data, _), (test_data, _) = mnist.load_data() # Normalize and reshape the data train_data = preprocess(train_data) test_data = preprocess(test_data) # Create a copy of the data with added noise noisy_train_data = noise(train_data) noisy_test_data = noise(test_data) # Display the train data and a version of it with added noise display(train_data, noisy_train_data) png Build the autoencoder We are going to use the Functional API to build our convolutional autoencoder. input = layers.Input(shape=(28, 28, 1)) # Encoder x = layers.Conv2D(32, (3, 3), activation=\"relu\", padding=\"same\")(input) x = layers.MaxPooling2D((2, 2), padding=\"same\")(x) x = layers.Conv2D(32, (3, 3), activation=\"relu\", padding=\"same\")(x) x = layers.MaxPooling2D((2, 2), padding=\"same\")(x) # Decoder x = layers.Conv2DTranspose(32, (3, 3), strides=2, activation=\"relu\", padding=\"same\")(x) x = layers.Conv2DTranspose(32, (3, 3), strides=2, activation=\"relu\", padding=\"same\")(x) x = layers.Conv2D(1, (3, 3), activation=\"sigmoid\", padding=\"same\")(x) # Autoencoder autoencoder = Model(input, x) autoencoder.compile(optimizer=\"adam\", loss=\"binary_crossentropy\") autoencoder.summary() Model: \"model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 28, 28, 1)] 0 _________________________________________________________________ conv2d (Conv2D) (None, 28, 28, 32) 320 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 14, 14, 32) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 14, 14, 32) 9248 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 7, 7, 32) 0 _________________________________________________________________ conv2d_transpose (Conv2DTran (None, 14, 14, 32) 9248 _________________________________________________________________ conv2d_transpose_1 (Conv2DTr (None, 28, 28, 32) 9248 _________________________________________________________________ conv2d_2 (Conv2D) (None, 28, 28, 1) 289 ================================================================= Total params: 28,353 Trainable params: 28,353 Non-trainable params: 0 _________________________________________________________________ Now we can train our autoencoder using train_data as both our input data and target. Notice we are setting up the validation data using the same format. autoencoder.fit( x=train_data, y=train_data, epochs=50, batch_size=128, shuffle=True, validation_data=(test_data, test_data), ) Epoch 1/50 469/469 [==============================] - 20s 43ms/step - loss: 0.1354 - val_loss: 0.0735 Epoch 2/50 469/469 [==============================] - 21s 45ms/step - loss: 0.0719 - val_loss: 0.0698 Epoch 3/50 469/469 [==============================] - 22s 47ms/step - loss: 0.0695 - val_loss: 0.0682 Epoch 4/50 469/469 [==============================] - 23s 50ms/step - loss: 0.0684 - val_loss: 0.0674 Epoch 5/50 469/469 [==============================] - 24s 51ms/step - loss: 0.0676 - val_loss: 0.0669 Epoch 6/50 469/469 [==============================] - 26s 55ms/step - loss: 0.0671 - val_loss: 0.0663 Epoch 7/50 469/469 [==============================] - 27s 57ms/step - loss: 0.0667 - val_loss: 0.0660 Epoch 8/50 469/469 [==============================] - 26s 56ms/step - loss: 0.0663 - val_loss: 0.0657 Epoch 9/50 469/469 [==============================] - 28s 59ms/step - loss: 0.0642 - val_loss: 0.0639 Epoch 21/50 469/469 [==============================] - 28s 60ms/step - loss: 0.0642 - val_loss: 0.0638 Epoch 22/50 469/469 [==============================] - 29s 62ms/step - loss: 0.0632 - val_loss: 0.0629 Epoch 38/50 397/469 [========================>.....] - ETA: 4s - loss: 0.0632 Let's predict on our test dataset and display the original image together with the prediction from our autoencoder. Notice how the predictions are pretty close to the original images, although not quite the same. predictions = autoencoder.predict(test_data) display(test_data, predictions) png Now that we know that our autoencoder works, let's retrain it using the noisy data as our input and the clean data as our target. We want our autoencoder to learn how to denoise the images. autoencoder.fit( x=noisy_train_data, y=train_data, epochs=100, batch_size=128, shuffle=True, validation_data=(noisy_test_data, test_data), ) Epoch 1/100 469/469 [==============================] - 28s 59ms/step - loss: 0.1027 - val_loss: 0.0946 Epoch 2/100 469/469 [==============================] - 27s 57ms/step - loss: 0.0942 - val_loss: 0.0924 Epoch 3/100 469/469 [==============================] - 27s 58ms/step - loss: 0.0925 - val_loss: 0.0913 Epoch 4/100 469/469 [==============================] - 28s 60ms/step - loss: 0.0915 - val_loss: 0.0905 Epoch 5/100 469/469 [==============================] - 31s 66ms/step - loss: 0.0908 - val_loss: 0.0897 Epoch 6/100 469/469 [==============================] - 30s 64ms/step - loss: 0.0902 - val_loss: 0.0893 Epoch 7/100 469/469 [==============================] - 28s 60ms/step - loss: 0.0897 - val_loss: 0.0887 Epoch 8/100 469/469 [==============================] - 31s 66ms/step - loss: 0.0872 - val_loss: 0.0867 Epoch 19/100 469/469 [==============================] - 30s 64ms/step - loss: 0.0860 - val_loss: 0.0854 Epoch 35/100 469/469 [==============================] - 32s 68ms/step - loss: 0.0854 - val_loss: 0.0849 Epoch 52/100 469/469 [==============================] - 28s 60ms/step - loss: 0.0851 - val_loss: 0.0847 Epoch 68/100 469/469 [==============================] - 31s 66ms/step - loss: 0.0851 - val_loss: 0.0848 Epoch 69/100 469/469 [==============================] - 31s 65ms/step - loss: 0.0849 - val_loss: 0.0847 Epoch 84/100 469/469 [==============================] - 29s 63ms/step - loss: 0.0848 - val_loss: 0.0846 Let's now predict on the noisy data and display the results of our autoencoder. Notice how the autoencoder does an amazing job at removing the noise from the input images. predictions = autoencoder.predict(noisy_test_data) display(noisy_test_data, predictions) png Data augmentation with CutMix for image classification on CIFAR-10. Introduction CutMix is a data augmentation technique that addresses the issue of information loss and inefficiency present in regional dropout strategies. Instead of removing pixels and filling them with black or grey pixels or Gaussian noise, you replace the removed regions with a patch from another image, while the ground truth labels are mixed proportionally to the number of pixels of combined images. CutMix was proposed in CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features (Yun et al., 2019) It's implemented via the following formulas: where M is the binary mask which indicates the cutout and the fill-in regions from the two randomly drawn images and λ (in [0, 1]) is drawn from a Beta(α, α) distribution The coordinates of bounding boxes are: which indicates the cutout and fill-in regions in case of the images. The bounding box sampling is represented by: where rx, ry are randomly drawn from a uniform distribution with upper bound. Setup import numpy as np import pandas as pd import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras np.random.seed(42) tf.random.set_seed(42) Load the CIFAR-10 dataset In this example, we will use the CIFAR-10 image classification dataset. (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data() y_train = tf.keras.utils.to_categorical(y_train, num_classes=10) y_test = tf.keras.utils.to_categorical(y_test, num_classes=10) print(x_train.shape) print(y_train.shape) print(x_test.shape) print(y_test.shape) class_names = [ \"Airplane\", \"Automobile\", \"Bird\", \"Cat\", \"Deer\", \"Dog\", \"Frog\", \"Horse\", \"Ship\", \"Truck\", ] (50000, 32, 32, 3) (50000, 10) (10000, 32, 32, 3) (10000, 10) Define hyperparameters AUTO = tf.data.AUTOTUNE BATCH_SIZE = 32 IMG_SIZE = 32 Define the image preprocessing function def preprocess_image(image, label): image = tf.image.resize(image, (IMG_SIZE, IMG_SIZE)) image = tf.image.convert_image_dtype(image, tf.float32) / 255.0 return image, label Convert the data into TensorFlow Dataset objects train_ds_one = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(1024) .map(preprocess_image, num_parallel_calls=AUTO) ) train_ds_two = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(1024) .map(preprocess_image, num_parallel_calls=AUTO) ) train_ds_simple = tf.data.Dataset.from_tensor_slices((x_train, y_train)) test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)) train_ds_simple = ( train_ds_simple.map(preprocess_image, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) # Combine two shuffled datasets from the same training data. train_ds = tf.data.Dataset.zip((train_ds_one, train_ds_two)) test_ds = ( test_ds.map(preprocess_image, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) Define the CutMix data augmentation function The CutMix function takes two image and label pairs to perform the augmentation. It samples λ(l) from the Beta distribution and returns a bounding box from get_box function. We then crop the second image (image2) and pad this image in the final padded image at the same location. def sample_beta_distribution(size, concentration_0=0.2, concentration_1=0.2): gamma_1_sample = tf.random.gamma(shape=[size], alpha=concentration_1) gamma_2_sample = tf.random.gamma(shape=[size], alpha=concentration_0) return gamma_1_sample / (gamma_1_sample + gamma_2_sample) @tf.function def get_box(lambda_value): cut_rat = tf.math.sqrt(1.0 - lambda_value) cut_w = IMG_SIZE * cut_rat # rw cut_w = tf.cast(cut_w, tf.int32) cut_h = IMG_SIZE * cut_rat # rh cut_h = tf.cast(cut_h, tf.int32) cut_x = tf.random.uniform((1,), minval=0, maxval=IMG_SIZE, dtype=tf.int32) # rx cut_y = tf.random.uniform((1,), minval=0, maxval=IMG_SIZE, dtype=tf.int32) # ry boundaryx1 = tf.clip_by_value(cut_x[0] - cut_w // 2, 0, IMG_SIZE) boundaryy1 = tf.clip_by_value(cut_y[0] - cut_h // 2, 0, IMG_SIZE) bbx2 = tf.clip_by_value(cut_x[0] + cut_w // 2, 0, IMG_SIZE) bby2 = tf.clip_by_value(cut_y[0] + cut_h // 2, 0, IMG_SIZE) target_h = bby2 - boundaryy1 if target_h == 0: target_h += 1 target_w = bbx2 - boundaryx1 if target_w == 0: target_w += 1 return boundaryx1, boundaryy1, target_h, target_w @tf.function def cutmix(train_ds_one, train_ds_two): (image1, label1), (image2, label2) = train_ds_one, train_ds_two alpha = [0.25] beta = [0.25] # Get a sample from the Beta distribution lambda_value = sample_beta_distribution(1, alpha, beta) # Define Lambda lambda_value = lambda_value[0][0] # Get the bounding box offsets, heights and widths boundaryx1, boundaryy1, target_h, target_w = get_box(lambda_value) # Get a patch from the second image (`image2`) crop2 = tf.image.crop_to_bounding_box( image2, boundaryy1, boundaryx1, target_h, target_w ) # Pad the `image2` patch (`crop2`) with the same offset image2 = tf.image.pad_to_bounding_box( crop2, boundaryy1, boundaryx1, IMG_SIZE, IMG_SIZE ) # Get a patch from the first image (`image1`) crop1 = tf.image.crop_to_bounding_box( image1, boundaryy1, boundaryx1, target_h, target_w ) # Pad the `image1` patch (`crop1`) with the same offset img1 = tf.image.pad_to_bounding_box( crop1, boundaryy1, boundaryx1, IMG_SIZE, IMG_SIZE ) # Modify the first image by subtracting the patch from `image1` # (before applying the `image2` patch) image1 = image1 - img1 # Add the modified `image1` and `image2` together to get the CutMix image image = image1 + image2 # Adjust Lambda in accordance to the pixel ration lambda_value = 1 - (target_w * target_h) / (IMG_SIZE * IMG_SIZE) lambda_value = tf.cast(lambda_value, tf.float32) # Combine the labels of both images label = lambda_value * label1 + (1 - lambda_value) * label2 return image, label Note: we are combining two images to create a single one. Visualize the new dataset after applying the CutMix augmentation # Create the new dataset using our `cutmix` utility train_ds_cmu = ( train_ds.shuffle(1024) .map(cutmix, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) # Let's preview 9 samples from the dataset image_batch, label_batch = next(iter(train_ds_cmu)) plt.figure(figsize=(10, 10)) for i in range(9): ax = plt.subplot(3, 3, i + 1) plt.title(class_names[np.argmax(label_batch[i])]) plt.imshow(image_batch[i]) plt.axis(\"off\") png Define a ResNet-20 model def resnet_layer( inputs, num_filters=16, kernel_size=3, strides=1, activation=\"relu\", batch_normalization=True, conv_first=True, ): conv = keras.layers.Conv2D( num_filters, kernel_size=kernel_size, strides=strides, padding=\"same\", kernel_initializer=\"he_normal\", kernel_regularizer=keras.regularizers.l2(1e-4), ) x = inputs if conv_first: x = conv(x) if batch_normalization: x = keras.layers.BatchNormalization()(x) if activation is not None: x = keras.layers.Activation(activation)(x) else: if batch_normalization: x = keras.layers.BatchNormalization()(x) if activation is not None: x = keras.layers.Activation(activation)(x) x = conv(x) return x def resnet_v20(input_shape, depth, num_classes=10): if (depth - 2) % 6 != 0: raise ValueError(\"depth should be 6n+2 (eg 20, 32, 44 in [a])\") # Start model definition. num_filters = 16 num_res_blocks = int((depth - 2) / 6) inputs = keras.layers.Input(shape=input_shape) x = resnet_layer(inputs=inputs) # Instantiate the stack of residual units for stack in range(3): for res_block in range(num_res_blocks): strides = 1 if stack > 0 and res_block == 0: # first layer but not first stack strides = 2 # downsample y = resnet_layer(inputs=x, num_filters=num_filters, strides=strides) y = resnet_layer(inputs=y, num_filters=num_filters, activation=None) if stack > 0 and res_block == 0: # first layer but not first stack # linear projection residual shortcut connection to match # changed dims x = resnet_layer( inputs=x, num_filters=num_filters, kernel_size=1, strides=strides, activation=None, batch_normalization=False, ) x = keras.layers.add([x, y]) x = keras.layers.Activation(\"relu\")(x) num_filters *= 2 # Add classifier on top. # v1 does not use BN after last shortcut connection-ReLU x = keras.layers.AveragePooling2D(pool_size=8)(x) y = keras.layers.Flatten()(x) outputs = keras.layers.Dense( num_classes, activation=\"softmax\", kernel_initializer=\"he_normal\" )(y) # Instantiate model. model = keras.models.Model(inputs=inputs, outputs=outputs) return model def training_model(): return resnet_v20((32, 32, 3), 20) initial_model = training_model() initial_model.save_weights(\"initial_weights.h5\") Train the model with the dataset augmented by CutMix model = training_model() model.load_weights(\"initial_weights.h5\") model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) model.fit(train_ds_cmu, validation_data=test_ds, epochs=15) test_loss, test_accuracy = model.evaluate(test_ds) print(\"Test accuracy: {:.2f}%\".format(test_accuracy * 100)) Epoch 1/15 1563/1563 [==============================] - 62s 24ms/step - loss: 1.9216 - accuracy: 0.4090 - val_loss: 1.9737 - val_accuracy: 0.4061 Epoch 2/15 1563/1563 [==============================] - 37s 24ms/step - loss: 1.6549 - accuracy: 0.5325 - val_loss: 1.5033 - val_accuracy: 0.5061 Epoch 3/15 1563/1563 [==============================] - 38s 24ms/step - loss: 1.5536 - accuracy: 0.5840 - val_loss: 1.2913 - val_accuracy: 0.6112 Epoch 4/15 1563/1563 [==============================] - 38s 24ms/step - loss: 1.4988 - accuracy: 0.6097 - val_loss: 1.0587 - val_accuracy: 0.7033 Epoch 5/15 1563/1563 [==============================] - 38s 24ms/step - loss: 1.4531 - accuracy: 0.6291 - val_loss: 1.0681 - val_accuracy: 0.6841 Epoch 6/15 1563/1563 [==============================] - 37s 24ms/step - loss: 1.4173 - accuracy: 0.6464 - val_loss: 1.0265 - val_accuracy: 0.7085 Epoch 7/15 1563/1563 [==============================] - 37s 24ms/step - loss: 1.3932 - accuracy: 0.6572 - val_loss: 0.9540 - val_accuracy: 0.7331 Epoch 8/15 1563/1563 [==============================] - 37s 24ms/step - loss: 1.3736 - accuracy: 0.6680 - val_loss: 0.9877 - val_accuracy: 0.7240 Epoch 9/15 1563/1563 [==============================] - 38s 24ms/step - loss: 1.3575 - accuracy: 0.6782 - val_loss: 0.8944 - val_accuracy: 0.7570 Epoch 10/15 1563/1563 [==============================] - 38s 24ms/step - loss: 1.3398 - accuracy: 0.6886 - val_loss: 0.8598 - val_accuracy: 0.7649 Epoch 11/15 1563/1563 [==============================] - 38s 24ms/step - loss: 1.3277 - accuracy: 0.6939 - val_loss: 0.9032 - val_accuracy: 0.7603 Epoch 12/15 1563/1563 [==============================] - 38s 24ms/step - loss: 1.3131 - accuracy: 0.6964 - val_loss: 0.7934 - val_accuracy: 0.7926 Epoch 13/15 1563/1563 [==============================] - 37s 24ms/step - loss: 1.3050 - accuracy: 0.7029 - val_loss: 0.8737 - val_accuracy: 0.7552 Epoch 14/15 1563/1563 [==============================] - 37s 24ms/step - loss: 1.2987 - accuracy: 0.7099 - val_loss: 0.8409 - val_accuracy: 0.7766 Epoch 15/15 1563/1563 [==============================] - 37s 24ms/step - loss: 1.2953 - accuracy: 0.7099 - val_loss: 0.7850 - val_accuracy: 0.8014 313/313 [==============================] - 3s 9ms/step - loss: 0.7850 - accuracy: 0.8014 Test accuracy: 80.14% Train the model using the original non-augmented dataset model = training_model() model.load_weights(\"initial_weights.h5\") model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) model.fit(train_ds_simple, validation_data=test_ds, epochs=15) test_loss, test_accuracy = model.evaluate(test_ds) print(\"Test accuracy: {:.2f}%\".format(test_accuracy * 100)) Epoch 1/15 1563/1563 [==============================] - 38s 23ms/step - loss: 1.4864 - accuracy: 0.5173 - val_loss: 1.3694 - val_accuracy: 0.5708 Epoch 2/15 1563/1563 [==============================] - 36s 23ms/step - loss: 1.0682 - accuracy: 0.6779 - val_loss: 1.1424 - val_accuracy: 0.6686 Epoch 3/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.8955 - accuracy: 0.7449 - val_loss: 1.0555 - val_accuracy: 0.7007 Epoch 4/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.7890 - accuracy: 0.7878 - val_loss: 1.0575 - val_accuracy: 0.7079 Epoch 5/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.7107 - accuracy: 0.8175 - val_loss: 1.1395 - val_accuracy: 0.7062 Epoch 6/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.6524 - accuracy: 0.8397 - val_loss: 1.1716 - val_accuracy: 0.7042 Epoch 7/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.6098 - accuracy: 0.8594 - val_loss: 1.4120 - val_accuracy: 0.6786 Epoch 8/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.5715 - accuracy: 0.8765 - val_loss: 1.3159 - val_accuracy: 0.7011 Epoch 9/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.5477 - accuracy: 0.8872 - val_loss: 1.2873 - val_accuracy: 0.7182 Epoch 10/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.5233 - accuracy: 0.8988 - val_loss: 1.4118 - val_accuracy: 0.6964 Epoch 11/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.5165 - accuracy: 0.9045 - val_loss: 1.3741 - val_accuracy: 0.7230 Epoch 12/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.5008 - accuracy: 0.9124 - val_loss: 1.3984 - val_accuracy: 0.7181 Epoch 13/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.4896 - accuracy: 0.9190 - val_loss: 1.3642 - val_accuracy: 0.7209 Epoch 14/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.4845 - accuracy: 0.9231 - val_loss: 1.5469 - val_accuracy: 0.6992 Epoch 15/15 1563/1563 [==============================] - 36s 23ms/step - loss: 0.4749 - accuracy: 0.9294 - val_loss: 1.4034 - val_accuracy: 0.7362 313/313 [==============================] - 3s 9ms/step - loss: 1.4034 - accuracy: 0.7362 Test accuracy: 73.62% Notes In this example, we trained our model for 15 epochs. In our experiment, the model with CutMix achieves a better accuracy on the CIFAR-10 dataset (80.36% in our experiment) compared to the model that doesn't use the augmentation (72.70%). You may notice it takes less time to train the model with the CutMix augmentation. You can experiment further with the CutMix technique by following the original paper. Few-shot classification of the Omniglot dataset using Reptile. Introduction The Reptile algorithm was developed by OpenAI to perform model agnostic meta-learning. Specifically, this algorithm was designed to quickly learn to perform new tasks with minimal training (few-shot learning). The algorithm works by performing Stochastic Gradient Descent using the difference between weights trained on a mini-batch of never before seen data and the model weights prior to training over a fixed number of meta-iterations. import matplotlib.pyplot as plt import numpy as np import random import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_datasets as tfds Define the Hyperparameters learning_rate = 0.003 meta_step_size = 0.25 inner_batch_size = 25 eval_batch_size = 25 meta_iters = 2000 eval_iters = 5 inner_iters = 4 eval_interval = 1 train_shots = 20 shots = 5 classes = 5 Prepare the data The Omniglot dataset is a dataset of 1,623 characters taken from 50 different alphabets, with 20 examples for each character. The 20 samples for each character were drawn online via Amazon's Mechanical Turk. For the few-shot learning task, k samples (or \"shots\") are drawn randomly from n randomly-chosen classes. These n numerical values are used to create a new set of temporary labels to use to test the model's ability to learn a new task given few examples. In other words, if you are training on 5 classes, your new class labels will be either 0, 1, 2, 3, or 4. Omniglot is a great dataset for this task since there are many different classes to draw from, with a reasonable number of samples for each class. class Dataset: # This class will facilitate the creation of a few-shot dataset # from the Omniglot dataset that can be sampled from quickly while also # allowing to create new labels at the same time. def __init__(self, training): # Download the tfrecord files containing the omniglot data and convert to a # dataset. split = \"train\" if training else \"test\" ds = tfds.load(\"omniglot\", split=split, as_supervised=True, shuffle_files=False) # Iterate over the dataset to get each individual image and its class, # and put that data into a dictionary. self.data = {} def extraction(image, label): # This function will shrink the Omniglot images to the desired size, # scale pixel values and convert the RGB image to grayscale image = tf.image.convert_image_dtype(image, tf.float32) image = tf.image.rgb_to_grayscale(image) image = tf.image.resize(image, [28, 28]) return image, label for image, label in ds.map(extraction): image = image.numpy() label = str(label.numpy()) if label not in self.data: self.data[label] = [] self.data[label].append(image) self.labels = list(self.data.keys()) def get_mini_dataset( self, batch_size, repetitions, shots, num_classes, split=False ): temp_labels = np.zeros(shape=(num_classes * shots)) temp_images = np.zeros(shape=(num_classes * shots, 28, 28, 1)) if split: test_labels = np.zeros(shape=(num_classes)) test_images = np.zeros(shape=(num_classes, 28, 28, 1)) # Get a random subset of labels from the entire label set. label_subset = random.choices(self.labels, k=num_classes) for class_idx, class_obj in enumerate(label_subset): # Use enumerated index value as a temporary label for mini-batch in # few shot learning. temp_labels[class_idx * shots : (class_idx + 1) * shots] = class_idx # If creating a split dataset for testing, select an extra sample from each # label to create the test dataset. if split: test_labels[class_idx] = class_idx images_to_split = random.choices( self.data[label_subset[class_idx]], k=shots + 1 ) test_images[class_idx] = images_to_split[-1] temp_images[ class_idx * shots : (class_idx + 1) * shots ] = images_to_split[:-1] else: # For each index in the randomly selected label_subset, sample the # necessary number of images. temp_images[ class_idx * shots : (class_idx + 1) * shots ] = random.choices(self.data[label_subset[class_idx]], k=shots) dataset = tf.data.Dataset.from_tensor_slices( (temp_images.astype(np.float32), temp_labels.astype(np.int32)) ) dataset = dataset.shuffle(100).batch(batch_size).repeat(repetitions) if split: return dataset, test_images, test_labels return dataset import urllib3 urllib3.disable_warnings() # Disable SSL warnings that may happen during download. train_dataset = Dataset(training=True) test_dataset = Dataset(training=False) Downloading and preparing dataset omniglot/3.0.0 (download: 17.95 MiB, generated: Unknown size, total: 17.95 MiB) to /root/tensorflow_datasets/omniglot/3.0.0... HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Dl Completed...', max=1.0, style=Progre… HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Dl Size...', max=1.0, style=ProgressSty… HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Extraction completed...', max=1.0, styl… HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value=''))) Shuffling and writing examples to /root/tensorflow_datasets/omniglot/3.0.0.incompleteXTNZJN/omniglot-train.tfrecord HBox(children=(FloatProgress(value=0.0, max=19280.0), HTML(value=''))) HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value=''))) Shuffling and writing examples to /root/tensorflow_datasets/omniglot/3.0.0.incompleteXTNZJN/omniglot-test.tfrecord HBox(children=(FloatProgress(value=0.0, max=13180.0), HTML(value=''))) HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value=''))) Shuffling and writing examples to /root/tensorflow_datasets/omniglot/3.0.0.incompleteXTNZJN/omniglot-small1.tfrecord HBox(children=(FloatProgress(value=0.0, max=2720.0), HTML(value=''))) HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value=''))) Shuffling and writing examples to /root/tensorflow_datasets/omniglot/3.0.0.incompleteXTNZJN/omniglot-small2.tfrecord HBox(children=(FloatProgress(value=0.0, max=3120.0), HTML(value=''))) Dataset omniglot downloaded and prepared to /root/tensorflow_datasets/omniglot/3.0.0. Subsequent calls will reuse this data. Visualize some examples from the dataset _, axarr = plt.subplots(nrows=5, ncols=5, figsize=(20, 20)) sample_keys = list(train_dataset.data.keys()) for a in range(5): for b in range(5): temp_image = train_dataset.data[sample_keys[a]][b] temp_image = np.stack((temp_image[:, :, 0],) * 3, axis=2) temp_image *= 255 temp_image = np.clip(temp_image, 0, 255).astype(\"uint8\") if b == 2: axarr[a, b].set_title(\"Class : \" + sample_keys[a]) axarr[a, b].imshow(temp_image, cmap=\"gray\") axarr[a, b].xaxis.set_visible(False) axarr[a, b].yaxis.set_visible(False) plt.show() png Build the model def conv_bn(x): x = layers.Conv2D(filters=64, kernel_size=3, strides=2, padding=\"same\")(x) x = layers.BatchNormalization()(x) return layers.ReLU()(x) inputs = layers.Input(shape=(28, 28, 1)) x = conv_bn(inputs) x = conv_bn(x) x = conv_bn(x) x = conv_bn(x) x = layers.Flatten()(x) outputs = layers.Dense(classes, activation=\"softmax\")(x) model = keras.Model(inputs=inputs, outputs=outputs) model.compile() optimizer = keras.optimizers.SGD(learning_rate=learning_rate) Train the model training = [] testing = [] for meta_iter in range(meta_iters): frac_done = meta_iter / meta_iters cur_meta_step_size = (1 - frac_done) * meta_step_size # Temporarily save the weights from the model. old_vars = model.get_weights() # Get a sample from the full dataset. mini_dataset = train_dataset.get_mini_dataset( inner_batch_size, inner_iters, train_shots, classes ) for images, labels in mini_dataset: with tf.GradientTape() as tape: preds = model(images) loss = keras.losses.sparse_categorical_crossentropy(labels, preds) grads = tape.gradient(loss, model.trainable_weights) optimizer.apply_gradients(zip(grads, model.trainable_weights)) new_vars = model.get_weights() # Perform SGD for the meta step. for var in range(len(new_vars)): new_vars[var] = old_vars[var] + ( (new_vars[var] - old_vars[var]) * cur_meta_step_size ) # After the meta-learning step, reload the newly-trained weights into the model. model.set_weights(new_vars) # Evaluation loop if meta_iter % eval_interval == 0: accuracies = [] for dataset in (train_dataset, test_dataset): # Sample a mini dataset from the full dataset. train_set, test_images, test_labels = dataset.get_mini_dataset( eval_batch_size, eval_iters, shots, classes, split=True ) old_vars = model.get_weights() # Train on the samples and get the resulting accuracies. for images, labels in train_set: with tf.GradientTape() as tape: preds = model(images) loss = keras.losses.sparse_categorical_crossentropy(labels, preds) grads = tape.gradient(loss, model.trainable_weights) optimizer.apply_gradients(zip(grads, model.trainable_weights)) test_preds = model.predict(test_images) test_preds = tf.argmax(test_preds).numpy() num_correct = (test_preds == test_labels).sum() # Reset the weights after getting the evaluation accuracies. model.set_weights(old_vars) accuracies.append(num_correct / classes) training.append(accuracies[0]) testing.append(accuracies[1]) if meta_iter % 100 == 0: print( \"batch %d: train=%f test=%f\" % (meta_iter, accuracies[0], accuracies[1]) ) batch 0: train=0.000000 test=0.600000 batch 100: train=0.600000 test=0.800000 batch 200: train=1.000000 test=0.600000 batch 300: train=0.600000 test=0.800000 batch 400: train=0.800000 test=1.000000 batch 500: train=1.000000 test=0.600000 batch 600: train=1.000000 test=1.000000 batch 700: train=1.000000 test=1.000000 batch 800: train=1.000000 test=0.600000 batch 900: train=1.000000 test=1.000000 batch 1000: train=0.800000 test=1.000000 batch 1100: train=1.000000 test=0.600000 batch 1200: train=0.800000 test=1.000000 batch 1300: train=0.800000 test=1.000000 batch 1400: train=1.000000 test=1.000000 batch 1500: train=0.800000 test=1.000000 batch 1600: train=1.000000 test=1.000000 batch 1700: train=1.000000 test=0.800000 batch 1800: train=1.000000 test=1.000000 batch 1900: train=0.800000 test=1.000000 Visualize Results # First, some preprocessing to smooth the training and testing arrays for display. window_length = 100 train_s = np.r_[ training[window_length - 1 : 0 : -1], training, training[-1:-window_length:-1] ] test_s = np.r_[ testing[window_length - 1 : 0 : -1], testing, testing[-1:-window_length:-1] ] w = np.hamming(window_length) train_y = np.convolve(w / w.sum(), train_s, mode=\"valid\") test_y = np.convolve(w / w.sum(), test_s, mode=\"valid\") # Display the training accuracies. x = np.arange(0, len(test_y), 1) plt.plot(x, test_y, x, train_y) plt.legend([\"test\", \"train\"]) plt.grid() train_set, test_images, test_labels = dataset.get_mini_dataset( eval_batch_size, eval_iters, shots, classes, split=True ) for images, labels in train_set: with tf.GradientTape() as tape: preds = model(images) loss = keras.losses.sparse_categorical_crossentropy(labels, preds) grads = tape.gradient(loss, model.trainable_weights) optimizer.apply_gradients(zip(grads, model.trainable_weights)) test_preds = model.predict(test_images) test_preds = tf.argmax(test_preds).numpy() _, axarr = plt.subplots(nrows=1, ncols=5, figsize=(20, 20)) sample_keys = list(train_dataset.data.keys()) for i, ax in zip(range(5), axarr): temp_image = np.stack((test_images[i, :, :, 0],) * 3, axis=2) temp_image *= 255 temp_image = np.clip(temp_image, 0, 255).astype(\"uint8\") ax.set_title( \"Label : {}, Prediction : {}\".format(int(test_labels[i]), test_preds[i]) ) ax.imshow(temp_image, cmap=\"gray\") ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) plt.show() png png Mitigating resolution discrepancy between training and test sets. Introduction It is a common practice to use the same input image resolution while training and testing vision models. However, as investigated in Fixing the train-test resolution discrepancy (Touvron et al.), this practice leads to suboptimal performance. Data augmentation is an indispensable part of the training process of deep neural networks. For vision models, we typically use random resized crops during training and center crops during inference. This introduces a discrepancy in the object sizes seen during training and inference. As shown by Touvron et al., if we can fix this discrepancy, we can significantly boost model performance. In this example, we implement the FixRes techniques introduced by Touvron et al. to fix this discrepancy. Imports from tensorflow import keras from tensorflow.keras import layers import tensorflow as tf import tensorflow_datasets as tfds tfds.disable_progress_bar() import matplotlib.pyplot as plt Load the tf_flowers dataset train_dataset, val_dataset = tfds.load( \"tf_flowers\", split=[\"train[:90%]\", \"train[90%:]\"], as_supervised=True ) num_train = train_dataset.cardinality() num_val = val_dataset.cardinality() print(f\"Number of training examples: {num_train}\") print(f\"Number of validation examples: {num_val}\") Number of training examples: 3303 Number of validation examples: 367 Data preprocessing utilities We create three datasets: A dataset with a smaller resolution - 128x128. Two datasets with a larger resolution - 224x224. We will apply different augmentation transforms to the larger-resolution datasets. The idea of FixRes is to first train a model on a smaller resolution dataset and then fine-tune it on a larger resolution dataset. This simple yet effective recipe leads to non-trivial performance improvements. Please refer to the original paper for results. # Reference: https://github.com/facebookresearch/FixRes/blob/main/transforms_v2.py. batch_size = 128 auto = tf.data.AUTOTUNE smaller_size = 128 bigger_size = 224 size_for_resizing = int((bigger_size / smaller_size) * bigger_size) central_crop_layer = layers.CenterCrop(bigger_size, bigger_size) def preprocess_initial(train, image_size): \"\"\"Initial preprocessing function for training on smaller resolution. For training, do random_horizontal_flip -> random_crop. For validation, just resize. No color-jittering has been used. \"\"\" def _pp(image, label, train): if train: channels = image.shape[-1] begin, size, _ = tf.image.sample_distorted_bounding_box( tf.shape(image), tf.zeros([0, 0, 4], tf.float32), area_range=(0.05, 1.0), min_object_covered=0, use_image_if_no_bounding_boxes=True, ) image = tf.slice(image, begin, size) image.set_shape([None, None, channels]) image = tf.image.resize(image, [image_size, image_size]) image = tf.image.random_flip_left_right(image) else: image = tf.image.resize(image, [image_size, image_size]) return image, label return _pp def preprocess_finetune(image, label, train): \"\"\"Preprocessing function for fine-tuning on a higher resolution. For training, resize to a bigger resolution to maintain the ratio -> random_horizontal_flip -> center_crop. For validation, do the same without any horizontal flipping. No color-jittering has been used. \"\"\" image = tf.image.resize(image, [size_for_resizing, size_for_resizing]) if train: image = tf.image.random_flip_left_right(image) image = central_crop_layer(image[None, ...])[0] return image, label def make_dataset( dataset: tf.data.Dataset, train: bool, image_size: int = smaller_size, fixres: bool = True, num_parallel_calls=auto, ): if image_size not in [smaller_size, bigger_size]: raise ValueError(f\"{image_size} resolution is not supported.\") # Determine which preprocessing function we are using. if image_size == smaller_size: preprocess_func = preprocess_initial(train, image_size) elif not fixres and image_size == bigger_size: preprocess_func = preprocess_initial(train, image_size) else: preprocess_func = preprocess_finetune if train: dataset = dataset.shuffle(batch_size * 10) return ( dataset.map( lambda x, y: preprocess_func(x, y, train), num_parallel_calls=num_parallel_calls, ) .batch(batch_size) .prefetch(num_parallel_calls) ) Notice how the augmentation transforms vary for the kind of dataset we are preparing. Prepare datasets initial_train_dataset = make_dataset(train_dataset, train=True, image_size=smaller_size) initial_val_dataset = make_dataset(val_dataset, train=False, image_size=smaller_size) finetune_train_dataset = make_dataset(train_dataset, train=True, image_size=bigger_size) finetune_val_dataset = make_dataset(val_dataset, train=False, image_size=bigger_size) vanilla_train_dataset = make_dataset( train_dataset, train=True, image_size=bigger_size, fixres=False ) vanilla_val_dataset = make_dataset( val_dataset, train=False, image_size=bigger_size, fixres=False ) Visualize the datasets def visualize_dataset(batch_images): plt.figure(figsize=(10, 10)) for n in range(25): ax = plt.subplot(5, 5, n + 1) plt.imshow(batch_images[n].numpy().astype(\"int\")) plt.axis(\"off\") plt.show() print(f\"Batch shape: {batch_images.shape}.\") # Smaller resolution. initial_sample_images, _ = next(iter(initial_train_dataset)) visualize_dataset(initial_sample_images) # Bigger resolution, only for fine-tuning. finetune_sample_images, _ = next(iter(finetune_train_dataset)) visualize_dataset(finetune_sample_images) # Bigger resolution, with the same augmentation transforms as # the smaller resolution dataset. vanilla_sample_images, _ = next(iter(vanilla_train_dataset)) visualize_dataset(vanilla_sample_images) 2021-10-11 02:05:26.638594: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. png Batch shape: (128, 128, 128, 3). 2021-10-11 02:05:28.509752: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. png Batch shape: (128, 224, 224, 3). 2021-10-11 02:05:30.108623: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. png Batch shape: (128, 224, 224, 3). Model training utilities We train multiple variants of ResNet50V2 (He et al.): On the smaller resolution dataset (128x128). It will be trained from scratch. Then fine-tune the model from 1 on the larger resolution (224x224) dataset. Train another ResNet50V2 from scratch on the larger resolution dataset. As a reminder, the larger resolution datasets differ in terms of their augmentation transforms. def get_training_model(num_classes=5): inputs = layers.Input((None, None, 3)) resnet_base = keras.applications.ResNet50V2( include_top=False, weights=None, pooling=\"avg\" ) resnet_base.trainable = True x = layers.Rescaling(scale=1.0 / 127.5, offset=-1)(inputs) x = resnet_base(x) outputs = layers.Dense(num_classes, activation=\"softmax\")(x) return keras.Model(inputs, outputs) def train_and_evaluate( model, train_ds, val_ds, epochs, learning_rate=1e-3, use_early_stopping=False ): optimizer = keras.optimizers.Adam(learning_rate=learning_rate) model.compile( optimizer=optimizer, loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"], ) if use_early_stopping: es_callback = keras.callbacks.EarlyStopping(patience=5) callbacks = [es_callback] else: callbacks = None model.fit( train_ds, validation_data=val_ds, epochs=epochs, callbacks=callbacks, ) _, accuracy = model.evaluate(val_ds) print(f\"Top-1 accuracy on the validation set: {accuracy*100:.2f}%.\") return model Experiment 1: Train on 128x128 and then fine-tune on 224x224 epochs = 30 smaller_res_model = get_training_model() smaller_res_model = train_and_evaluate( smaller_res_model, initial_train_dataset, initial_val_dataset, epochs ) Epoch 1/30 26/26 [==============================] - 14s 226ms/step - loss: 1.6476 - accuracy: 0.4345 - val_loss: 9.8213 - val_accuracy: 0.2044 Epoch 2/30 26/26 [==============================] - 3s 123ms/step - loss: 1.1561 - accuracy: 0.5495 - val_loss: 6.5521 - val_accuracy: 0.2071 Epoch 3/30 26/26 [==============================] - 3s 123ms/step - loss: 1.0989 - accuracy: 0.5722 - val_loss: 2.6216 - val_accuracy: 0.1935 Epoch 4/30 26/26 [==============================] - 3s 122ms/step - loss: 1.0373 - accuracy: 0.5895 - val_loss: 1.9918 - val_accuracy: 0.2125 Epoch 5/30 26/26 [==============================] - 3s 122ms/step - loss: 0.9960 - accuracy: 0.6119 - val_loss: 2.8505 - val_accuracy: 0.2262 Epoch 6/30 26/26 [==============================] - 3s 122ms/step - loss: 0.9458 - accuracy: 0.6331 - val_loss: 1.8974 - val_accuracy: 0.2834 Epoch 7/30 26/26 [==============================] - 3s 122ms/step - loss: 0.8949 - accuracy: 0.6606 - val_loss: 2.1164 - val_accuracy: 0.2834 Epoch 8/30 26/26 [==============================] - 3s 122ms/step - loss: 0.8581 - accuracy: 0.6709 - val_loss: 1.8858 - val_accuracy: 0.3815 Epoch 9/30 26/26 [==============================] - 3s 123ms/step - loss: 0.8436 - accuracy: 0.6776 - val_loss: 1.5671 - val_accuracy: 0.4687 Epoch 10/30 26/26 [==============================] - 3s 123ms/step - loss: 0.8632 - accuracy: 0.6685 - val_loss: 1.5005 - val_accuracy: 0.5504 Epoch 11/30 26/26 [==============================] - 3s 123ms/step - loss: 0.8316 - accuracy: 0.6918 - val_loss: 1.1421 - val_accuracy: 0.6594 Epoch 12/30 26/26 [==============================] - 3s 123ms/step - loss: 0.7981 - accuracy: 0.6951 - val_loss: 1.2036 - val_accuracy: 0.6403 Epoch 13/30 26/26 [==============================] - 3s 122ms/step - loss: 0.8275 - accuracy: 0.6806 - val_loss: 2.2632 - val_accuracy: 0.5177 Epoch 14/30 26/26 [==============================] - 3s 122ms/step - loss: 0.8156 - accuracy: 0.6994 - val_loss: 1.1023 - val_accuracy: 0.6649 Epoch 15/30 26/26 [==============================] - 3s 122ms/step - loss: 0.7572 - accuracy: 0.7091 - val_loss: 1.6248 - val_accuracy: 0.6049 Epoch 16/30 26/26 [==============================] - 3s 123ms/step - loss: 0.7757 - accuracy: 0.7024 - val_loss: 2.0600 - val_accuracy: 0.6294 Epoch 17/30 26/26 [==============================] - 3s 122ms/step - loss: 0.7600 - accuracy: 0.7087 - val_loss: 1.5731 - val_accuracy: 0.6131 Epoch 18/30 26/26 [==============================] - 3s 122ms/step - loss: 0.7385 - accuracy: 0.7215 - val_loss: 1.8312 - val_accuracy: 0.5749 Epoch 19/30 26/26 [==============================] - 3s 122ms/step - loss: 0.7493 - accuracy: 0.7224 - val_loss: 3.0382 - val_accuracy: 0.4986 Epoch 20/30 26/26 [==============================] - 3s 122ms/step - loss: 0.7746 - accuracy: 0.7048 - val_loss: 7.8191 - val_accuracy: 0.5123 Epoch 21/30 26/26 [==============================] - 3s 123ms/step - loss: 0.7367 - accuracy: 0.7405 - val_loss: 1.9607 - val_accuracy: 0.6676 Epoch 22/30 26/26 [==============================] - 3s 122ms/step - loss: 0.6970 - accuracy: 0.7357 - val_loss: 3.1944 - val_accuracy: 0.4496 Epoch 23/30 26/26 [==============================] - 3s 122ms/step - loss: 0.7299 - accuracy: 0.7212 - val_loss: 1.4012 - val_accuracy: 0.6567 Epoch 24/30 26/26 [==============================] - 3s 122ms/step - loss: 0.6965 - accuracy: 0.7315 - val_loss: 1.9781 - val_accuracy: 0.6403 Epoch 25/30 26/26 [==============================] - 3s 124ms/step - loss: 0.6811 - accuracy: 0.7408 - val_loss: 0.9287 - val_accuracy: 0.6839 Epoch 26/30 26/26 [==============================] - 3s 123ms/step - loss: 0.6732 - accuracy: 0.7487 - val_loss: 2.9406 - val_accuracy: 0.5504 Epoch 27/30 26/26 [==============================] - 3s 122ms/step - loss: 0.6571 - accuracy: 0.7560 - val_loss: 1.6268 - val_accuracy: 0.5804 Epoch 28/30 26/26 [==============================] - 3s 122ms/step - loss: 0.6662 - accuracy: 0.7548 - val_loss: 0.9067 - val_accuracy: 0.7357 Epoch 29/30 26/26 [==============================] - 3s 122ms/step - loss: 0.6443 - accuracy: 0.7520 - val_loss: 0.7760 - val_accuracy: 0.7520 Epoch 30/30 26/26 [==============================] - 3s 122ms/step - loss: 0.6617 - accuracy: 0.7539 - val_loss: 0.6026 - val_accuracy: 0.7766 3/3 [==============================] - 0s 37ms/step - loss: 0.6026 - accuracy: 0.7766 Top-1 accuracy on the validation set: 77.66%. Freeze all the layers except for the final Batch Normalization layer For fine-tuning, we train only two layers: The final Batch Normalization (Ioffe et al.) layer. The classification layer. We are unfreezing the final Batch Normalization layer to compensate for the change in activation statistics before the global average pooling layer. As shown in the paper, unfreezing the final Batch Normalization layer is enough. For a comprehensive guide on fine-tuning models in Keras, refer to this tutorial. for layer in smaller_res_model.layers[2].layers: layer.trainable = False smaller_res_model.layers[2].get_layer(\"post_bn\").trainable = True epochs = 10 # Use a lower learning rate during fine-tuning. bigger_res_model = train_and_evaluate( smaller_res_model, finetune_train_dataset, finetune_val_dataset, epochs, learning_rate=1e-4, ) Epoch 1/10 26/26 [==============================] - 9s 201ms/step - loss: 0.7912 - accuracy: 0.7856 - val_loss: 0.6808 - val_accuracy: 0.7575 Epoch 2/10 26/26 [==============================] - 3s 115ms/step - loss: 0.7732 - accuracy: 0.7938 - val_loss: 0.7028 - val_accuracy: 0.7684 Epoch 3/10 26/26 [==============================] - 3s 115ms/step - loss: 0.7658 - accuracy: 0.7923 - val_loss: 0.7136 - val_accuracy: 0.7629 Epoch 4/10 26/26 [==============================] - 3s 115ms/step - loss: 0.7536 - accuracy: 0.7872 - val_loss: 0.7161 - val_accuracy: 0.7684 Epoch 5/10 26/26 [==============================] - 3s 115ms/step - loss: 0.7346 - accuracy: 0.7947 - val_loss: 0.7154 - val_accuracy: 0.7711 Epoch 6/10 26/26 [==============================] - 3s 115ms/step - loss: 0.7183 - accuracy: 0.7990 - val_loss: 0.7139 - val_accuracy: 0.7684 Epoch 7/10 26/26 [==============================] - 3s 116ms/step - loss: 0.7059 - accuracy: 0.7962 - val_loss: 0.7071 - val_accuracy: 0.7738 Epoch 8/10 26/26 [==============================] - 3s 115ms/step - loss: 0.6959 - accuracy: 0.7923 - val_loss: 0.7002 - val_accuracy: 0.7738 Epoch 9/10 26/26 [==============================] - 3s 116ms/step - loss: 0.6871 - accuracy: 0.8011 - val_loss: 0.6967 - val_accuracy: 0.7711 Epoch 10/10 26/26 [==============================] - 3s 116ms/step - loss: 0.6761 - accuracy: 0.8044 - val_loss: 0.6887 - val_accuracy: 0.7738 3/3 [==============================] - 0s 95ms/step - loss: 0.6887 - accuracy: 0.7738 Top-1 accuracy on the validation set: 77.38%. Experiment 2: Train a model on 224x224 resolution from scratch Now, we train another model from scratch on the larger resolution dataset. Recall that the augmentation transforms used in this dataset are different from before. epochs = 30 vanilla_bigger_res_model = get_training_model() vanilla_bigger_res_model = train_and_evaluate( vanilla_bigger_res_model, vanilla_train_dataset, vanilla_val_dataset, epochs ) Epoch 1/30 26/26 [==============================] - 15s 389ms/step - loss: 1.5339 - accuracy: 0.4569 - val_loss: 177.5233 - val_accuracy: 0.1907 Epoch 2/30 26/26 [==============================] - 8s 314ms/step - loss: 1.1472 - accuracy: 0.5483 - val_loss: 17.5804 - val_accuracy: 0.1907 Epoch 3/30 26/26 [==============================] - 8s 315ms/step - loss: 1.0708 - accuracy: 0.5792 - val_loss: 2.2719 - val_accuracy: 0.2480 Epoch 4/30 26/26 [==============================] - 8s 315ms/step - loss: 1.0225 - accuracy: 0.6170 - val_loss: 2.1274 - val_accuracy: 0.2398 Epoch 5/30 26/26 [==============================] - 8s 316ms/step - loss: 1.0001 - accuracy: 0.6206 - val_loss: 2.0375 - val_accuracy: 0.2834 Epoch 6/30 26/26 [==============================] - 8s 315ms/step - loss: 0.9602 - accuracy: 0.6355 - val_loss: 1.4412 - val_accuracy: 0.3978 Epoch 7/30 26/26 [==============================] - 8s 316ms/step - loss: 0.9418 - accuracy: 0.6461 - val_loss: 1.5257 - val_accuracy: 0.4305 Epoch 8/30 26/26 [==============================] - 8s 316ms/step - loss: 0.8911 - accuracy: 0.6649 - val_loss: 1.1530 - val_accuracy: 0.5858 Epoch 9/30 26/26 [==============================] - 8s 316ms/step - loss: 0.8834 - accuracy: 0.6694 - val_loss: 1.2026 - val_accuracy: 0.5531 Epoch 10/30 26/26 [==============================] - 8s 316ms/step - loss: 0.8752 - accuracy: 0.6724 - val_loss: 1.4917 - val_accuracy: 0.5695 Epoch 11/30 26/26 [==============================] - 8s 316ms/step - loss: 0.8690 - accuracy: 0.6594 - val_loss: 1.4115 - val_accuracy: 0.6022 Epoch 12/30 26/26 [==============================] - 8s 314ms/step - loss: 0.8586 - accuracy: 0.6761 - val_loss: 1.0692 - val_accuracy: 0.6349 Epoch 13/30 26/26 [==============================] - 8s 315ms/step - loss: 0.8120 - accuracy: 0.6894 - val_loss: 1.5233 - val_accuracy: 0.6567 Epoch 14/30 26/26 [==============================] - 8s 316ms/step - loss: 0.8275 - accuracy: 0.6857 - val_loss: 1.9079 - val_accuracy: 0.5804 Epoch 15/30 26/26 [==============================] - 8s 316ms/step - loss: 0.7624 - accuracy: 0.7127 - val_loss: 0.9543 - val_accuracy: 0.6540 Epoch 16/30 26/26 [==============================] - 8s 315ms/step - loss: 0.7595 - accuracy: 0.7266 - val_loss: 4.5757 - val_accuracy: 0.4877 Epoch 17/30 26/26 [==============================] - 8s 315ms/step - loss: 0.7577 - accuracy: 0.7154 - val_loss: 1.8411 - val_accuracy: 0.5749 Epoch 18/30 26/26 [==============================] - 8s 316ms/step - loss: 0.7596 - accuracy: 0.7163 - val_loss: 1.0660 - val_accuracy: 0.6703 Epoch 19/30 26/26 [==============================] - 8s 315ms/step - loss: 0.7492 - accuracy: 0.7160 - val_loss: 1.2462 - val_accuracy: 0.6485 Epoch 20/30 26/26 [==============================] - 8s 315ms/step - loss: 0.7269 - accuracy: 0.7330 - val_loss: 5.8287 - val_accuracy: 0.3379 Epoch 21/30 26/26 [==============================] - 8s 315ms/step - loss: 0.7193 - accuracy: 0.7275 - val_loss: 4.7058 - val_accuracy: 0.6049 Epoch 22/30 26/26 [==============================] - 8s 316ms/step - loss: 0.7251 - accuracy: 0.7318 - val_loss: 1.5608 - val_accuracy: 0.6485 Epoch 23/30 26/26 [==============================] - 8s 314ms/step - loss: 0.6888 - accuracy: 0.7466 - val_loss: 1.7914 - val_accuracy: 0.6240 Epoch 24/30 26/26 [==============================] - 8s 314ms/step - loss: 0.7051 - accuracy: 0.7339 - val_loss: 2.0918 - val_accuracy: 0.6158 Epoch 25/30 26/26 [==============================] - 8s 315ms/step - loss: 0.6920 - accuracy: 0.7454 - val_loss: 0.7284 - val_accuracy: 0.7575 Epoch 26/30 26/26 [==============================] - 8s 316ms/step - loss: 0.6502 - accuracy: 0.7523 - val_loss: 2.5474 - val_accuracy: 0.5313 Epoch 27/30 26/26 [==============================] - 8s 315ms/step - loss: 0.7101 - accuracy: 0.7330 - val_loss: 26.8117 - val_accuracy: 0.3297 Epoch 28/30 26/26 [==============================] - 8s 315ms/step - loss: 0.6632 - accuracy: 0.7548 - val_loss: 20.1011 - val_accuracy: 0.3243 Epoch 29/30 26/26 [==============================] - 8s 315ms/step - loss: 0.6682 - accuracy: 0.7505 - val_loss: 11.5872 - val_accuracy: 0.3297 Epoch 30/30 26/26 [==============================] - 8s 315ms/step - loss: 0.6758 - accuracy: 0.7514 - val_loss: 5.7229 - val_accuracy: 0.4305 3/3 [==============================] - 0s 95ms/step - loss: 5.7229 - accuracy: 0.4305 Top-1 accuracy on the validation set: 43.05%. As we can notice from the above cells, FixRes leads to a better performance. Another advantage of FixRes is the improved total training time and reduction in GPU memory usage. FixRes is model-agnostic, you can use it on any image classification model to potentially boost performance. You can find more results here that were gathered by running the same code with different random seeds. How to obtain a class activation heatmap for an image classification model. Adapted from Deep Learning with Python (2017). Setup import numpy as np import tensorflow as tf from tensorflow import keras # Display from IPython.display import Image, display import matplotlib.pyplot as plt import matplotlib.cm as cm Configurable parameters You can change these to another model. To get the values for last_conv_layer_name use model.summary() to see the names of all layers in the model. model_builder = keras.applications.xception.Xception img_size = (299, 299) preprocess_input = keras.applications.xception.preprocess_input decode_predictions = keras.applications.xception.decode_predictions last_conv_layer_name = \"block14_sepconv2_act\" # The local path to our target image img_path = keras.utils.get_file( \"african_elephant.jpg\", \"https://i.imgur.com/Bvro0YD.png\" ) display(Image(img_path)) jpeg The Grad-CAM algorithm def get_img_array(img_path, size): # `img` is a PIL image of size 299x299 img = keras.preprocessing.image.load_img(img_path, target_size=size) # `array` is a float32 Numpy array of shape (299, 299, 3) array = keras.preprocessing.image.img_to_array(img) # We add a dimension to transform our array into a \"batch\" # of size (1, 299, 299, 3) array = np.expand_dims(array, axis=0) return array def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None): # First, we create a model that maps the input image to the activations # of the last conv layer as well as the output predictions grad_model = tf.keras.models.Model( [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output] ) # Then, we compute the gradient of the top predicted class for our input image # with respect to the activations of the last conv layer with tf.GradientTape() as tape: last_conv_layer_output, preds = grad_model(img_array) if pred_index is None: pred_index = tf.argmax(preds[0]) class_channel = preds[:, pred_index] # This is the gradient of the output neuron (top predicted or chosen) # with regard to the output feature map of the last conv layer grads = tape.gradient(class_channel, last_conv_layer_output) # This is a vector where each entry is the mean intensity of the gradient # over a specific feature map channel pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2)) # We multiply each channel in the feature map array # by \"how important this channel is\" with regard to the top predicted class # then sum all the channels to obtain the heatmap class activation last_conv_layer_output = last_conv_layer_output[0] heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis] heatmap = tf.squeeze(heatmap) # For visualization purpose, we will also normalize the heatmap between 0 & 1 heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap) return heatmap.numpy() Let's test-drive it # Prepare image img_array = preprocess_input(get_img_array(img_path, size=img_size)) # Make model model = model_builder(weights=\"imagenet\") # Remove last layer's softmax model.layers[-1].activation = None # Print what the top predicted class is preds = model.predict(img_array) print(\"Predicted:\", decode_predictions(preds, top=1)[0]) # Generate class activation heatmap heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name) # Display heatmap plt.matshow(heatmap) plt.show() Predicted: [('n02504458', 'African_elephant', 9.862388)] png Create a superimposed visualization def save_and_display_gradcam(img_path, heatmap, cam_path=\"cam.jpg\", alpha=0.4): # Load the original image img = keras.preprocessing.image.load_img(img_path) img = keras.preprocessing.image.img_to_array(img) # Rescale heatmap to a range 0-255 heatmap = np.uint8(255 * heatmap) # Use jet colormap to colorize heatmap jet = cm.get_cmap(\"jet\") # Use RGB values of the colormap jet_colors = jet(np.arange(256))[:, :3] jet_heatmap = jet_colors[heatmap] # Create an image with RGB colorized heatmap jet_heatmap = keras.preprocessing.image.array_to_img(jet_heatmap) jet_heatmap = jet_heatmap.resize((img.shape[1], img.shape[0])) jet_heatmap = keras.preprocessing.image.img_to_array(jet_heatmap) # Superimpose the heatmap on original image superimposed_img = jet_heatmap * alpha + img superimposed_img = keras.preprocessing.image.array_to_img(superimposed_img) # Save the superimposed image superimposed_img.save(cam_path) # Display Grad CAM display(Image(cam_path)) save_and_display_gradcam(img_path, heatmap) jpeg Let's try another image We will see how the grad cam explains the model's outputs for a multi-label image. Let's try an image with a cat and a dog together, and see how the grad cam behaves. img_path = keras.utils.get_file( \"cat_and_dog.jpg\", \"https://storage.googleapis.com/petbacker/images/blog/2017/dog-and-cat-cover.jpg\", ) display(Image(img_path)) # Prepare image img_array = preprocess_input(get_img_array(img_path, size=img_size)) # Print what the two top predicted classes are preds = model.predict(img_array) print(\"Predicted:\", decode_predictions(preds, top=2)[0]) jpeg Predicted: [('n02112137', 'chow', 4.611241), ('n02124075', 'Egyptian_cat', 4.3817368)] We generate class activation heatmap for \"chow,\" the class index is 260 heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=260) save_and_display_gradcam(img_path, heatmap) jpeg We generate class activation heatmap for \"egyptian cat,\" the class index is 285 heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=285) save_and_display_gradcam(img_path, heatmap) jpeg Implement Gradient Centralization to improve training performance of DNNs. Introduction This example implements Gradient Centralization, a new optimization technique for Deep Neural Networks by Yong et al., and demonstrates it on Laurence Moroney's Horses or Humans Dataset. Gradient Centralization can both speedup training process and improve the final generalization performance of DNNs. It operates directly on gradients by centralizing the gradient vectors to have zero mean. Gradient Centralization morever improves the Lipschitzness of the loss function and its gradient so that the training process becomes more efficient and stable. This example requires TensorFlow 2.2 or higher as well as tensorflow_datasets which can be installed with this command: pip install tensorflow-datasets We will be implementing Gradient Centralization in this example but you could also use this very easily with a package I built, gradient-centralization-tf. Setup from time import time import tensorflow as tf import tensorflow_datasets as tfds from tensorflow.keras import layers from tensorflow.keras.optimizers import RMSprop Prepare the data For this example, we will be using the Horses or Humans dataset. num_classes = 2 input_shape = (300, 300, 3) dataset_name = \"horses_or_humans\" batch_size = 128 AUTOTUNE = tf.data.AUTOTUNE (train_ds, test_ds), metadata = tfds.load( name=dataset_name, split=[tfds.Split.TRAIN, tfds.Split.TEST], with_info=True, as_supervised=True, ) print(f\"Image shape: {metadata.features['image'].shape}\") print(f\"Training images: {metadata.splits['train'].num_examples}\") print(f\"Test images: {metadata.splits['test'].num_examples}\") Image shape: (300, 300, 3) Training images: 1027 Test images: 256 Use Data Augmentation We will rescale the data to [0, 1] and perform simple augmentations to our data. rescale = layers.Rescaling(1.0 / 255) data_augmentation = tf.keras.Sequential( [ layers.RandomFlip(\"horizontal_and_vertical\"), layers.RandomRotation(0.3), layers.RandomZoom(0.2), ] ) def prepare(ds, shuffle=False, augment=False): # Rescale dataset ds = ds.map(lambda x, y: (rescale(x), y), num_parallel_calls=AUTOTUNE) if shuffle: ds = ds.shuffle(1024) # Batch dataset ds = ds.batch(batch_size) # Use data augmentation only on the training set if augment: ds = ds.map( lambda x, y: (data_augmentation(x, training=True), y), num_parallel_calls=AUTOTUNE, ) # Use buffered prefecting return ds.prefetch(buffer_size=AUTOTUNE) Rescale and augment the data train_ds = prepare(train_ds, shuffle=True, augment=True) test_ds = prepare(test_ds) Define a model In this section we will define a Convolutional neural network. model = tf.keras.Sequential( [ layers.Conv2D(16, (3, 3), activation=\"relu\", input_shape=(300, 300, 3)), layers.MaxPooling2D(2, 2), layers.Conv2D(32, (3, 3), activation=\"relu\"), layers.Dropout(0.5), layers.MaxPooling2D(2, 2), layers.Conv2D(64, (3, 3), activation=\"relu\"), layers.Dropout(0.5), layers.MaxPooling2D(2, 2), layers.Conv2D(64, (3, 3), activation=\"relu\"), layers.MaxPooling2D(2, 2), layers.Conv2D(64, (3, 3), activation=\"relu\"), layers.MaxPooling2D(2, 2), layers.Flatten(), layers.Dropout(0.5), layers.Dense(512, activation=\"relu\"), layers.Dense(1, activation=\"sigmoid\"), ] ) Implement Gradient Centralization We will now subclass the RMSProp optimizer class modifying the tf.keras.optimizers.Optimizer.get_gradients() method where we now implement Gradient Centralization. On a high level the idea is that let us say we obtain our gradients through back propogation for a Dense or Convolution layer we then compute the mean of the column vectors of the weight matrix, and then remove the mean from each column vector. The experiments in this paper on various applications, including general image classification, fine-grained image classification, detection and segmentation and Person ReID demonstrate that GC can consistently improve the performance of DNN learning. Also, for simplicity at the moment we are not implementing gradient cliiping functionality, however this quite easy to implement. At the moment we are just creating a subclass for the RMSProp optimizer however you could easily reproduce this for any other optimizer or on a custom optimizer in the same way. We will be using this class in the later section when we train a model with Gradient Centralization. class GCRMSprop(RMSprop): def get_gradients(self, loss, params): # We here just provide a modified get_gradients() function since we are # trying to just compute the centralized gradients. grads = [] gradients = super().get_gradients() for grad in gradients: grad_len = len(grad.shape) if grad_len > 1: axis = list(range(grad_len - 1)) grad -= tf.reduce_mean(grad, axis=axis, keep_dims=True) grads.append(grad) return grads optimizer = GCRMSprop(learning_rate=1e-4) Training utilities We will also create a callback which allows us to easily measure the total training time and the time taken for each epoch since we are interested in comparing the effect of Gradient Centralization on the model we built above. class TimeHistory(tf.keras.callbacks.Callback): def on_train_begin(self, logs={}): self.times = [] def on_epoch_begin(self, batch, logs={}): self.epoch_time_start = time() def on_epoch_end(self, batch, logs={}): self.times.append(time() - self.epoch_time_start) Train the model without GC We now train the model we built earlier without Gradient Centralization which we can compare to the training performance of the model trained with Gradient Centralization. time_callback_no_gc = TimeHistory() model.compile( loss=\"binary_crossentropy\", optimizer=RMSprop(learning_rate=1e-4), metrics=[\"accuracy\"], ) model.summary() Model: \"sequential_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 298, 298, 16) 448 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 149, 149, 16) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 147, 147, 32) 4640 _________________________________________________________________ dropout (Dropout) (None, 147, 147, 32) 0 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 73, 73, 32) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 71, 71, 64) 18496 _________________________________________________________________ dropout_1 (Dropout) (None, 71, 71, 64) 0 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 35, 35, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 33, 33, 64) 36928 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 16, 16, 64) 0 _________________________________________________________________ conv2d_4 (Conv2D) (None, 14, 14, 64) 36928 _________________________________________________________________ max_pooling2d_4 (MaxPooling2 (None, 7, 7, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 3136) 0 _________________________________________________________________ dropout_2 (Dropout) (None, 3136) 0 _________________________________________________________________ dense (Dense) (None, 512) 1606144 _________________________________________________________________ dense_1 (Dense) (None, 1) 513 ================================================================= Total params: 1,704,097 Trainable params: 1,704,097 Non-trainable params: 0 _________________________________________________________________ We also save the history since we later want to compare our model trained with and not trained with Gradient Centralization history_no_gc = model.fit( train_ds, epochs=10, verbose=1, callbacks=[time_callback_no_gc] ) Epoch 1/10 9/9 [==============================] - 5s 571ms/step - loss: 0.7427 - accuracy: 0.5073 Epoch 2/10 9/9 [==============================] - 6s 667ms/step - loss: 0.6757 - accuracy: 0.5433 Epoch 3/10 9/9 [==============================] - 6s 660ms/step - loss: 0.6616 - accuracy: 0.6144 Epoch 4/10 9/9 [==============================] - 6s 642ms/step - loss: 0.6598 - accuracy: 0.6203 Epoch 5/10 9/9 [==============================] - 6s 666ms/step - loss: 0.6782 - accuracy: 0.6329 Epoch 6/10 9/9 [==============================] - 6s 655ms/step - loss: 0.6550 - accuracy: 0.6524 Epoch 7/10 9/9 [==============================] - 6s 645ms/step - loss: 0.6157 - accuracy: 0.7186 Epoch 8/10 9/9 [==============================] - 6s 654ms/step - loss: 0.6095 - accuracy: 0.6913 Epoch 9/10 9/9 [==============================] - 6s 677ms/step - loss: 0.5880 - accuracy: 0.7147 Epoch 10/10 9/9 [==============================] - 6s 663ms/step - loss: 0.5814 - accuracy: 0.6933 Train the model with GC We will now train the same model, this time using Gradient Centralization, notice our optimizer is the one using Gradient Centralization this time. time_callback_gc = TimeHistory() model.compile(loss=\"binary_crossentropy\", optimizer=optimizer, metrics=[\"accuracy\"]) model.summary() history_gc = model.fit(train_ds, epochs=10, verbose=1, callbacks=[time_callback_gc]) Model: \"sequential_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 298, 298, 16) 448 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 149, 149, 16) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 147, 147, 32) 4640 _________________________________________________________________ dropout (Dropout) (None, 147, 147, 32) 0 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 73, 73, 32) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 71, 71, 64) 18496 _________________________________________________________________ dropout_1 (Dropout) (None, 71, 71, 64) 0 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 35, 35, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 33, 33, 64) 36928 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 16, 16, 64) 0 _________________________________________________________________ conv2d_4 (Conv2D) (None, 14, 14, 64) 36928 _________________________________________________________________ max_pooling2d_4 (MaxPooling2 (None, 7, 7, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 3136) 0 _________________________________________________________________ dropout_2 (Dropout) (None, 3136) 0 _________________________________________________________________ dense (Dense) (None, 512) 1606144 _________________________________________________________________ dense_1 (Dense) (None, 1) 513 ================================================================= Total params: 1,704,097 Trainable params: 1,704,097 Non-trainable params: 0 _________________________________________________________________ Epoch 1/10 9/9 [==============================] - 6s 673ms/step - loss: 0.6022 - accuracy: 0.7147 Epoch 2/10 9/9 [==============================] - 6s 662ms/step - loss: 0.5385 - accuracy: 0.7371 Epoch 3/10 9/9 [==============================] - 6s 673ms/step - loss: 0.4832 - accuracy: 0.7945 Epoch 4/10 9/9 [==============================] - 6s 645ms/step - loss: 0.4692 - accuracy: 0.7799 Epoch 5/10 9/9 [==============================] - 6s 720ms/step - loss: 0.4792 - accuracy: 0.7799 Epoch 6/10 9/9 [==============================] - 6s 658ms/step - loss: 0.4623 - accuracy: 0.7838 Epoch 7/10 9/9 [==============================] - 6s 651ms/step - loss: 0.4413 - accuracy: 0.8072 Epoch 8/10 9/9 [==============================] - 6s 682ms/step - loss: 0.4542 - accuracy: 0.8014 Epoch 9/10 9/9 [==============================] - 6s 649ms/step - loss: 0.4235 - accuracy: 0.8053 Epoch 10/10 9/9 [==============================] - 6s 686ms/step - loss: 0.4445 - accuracy: 0.7936 Comparing performance print(\"Not using Gradient Centralization\") print(f\"Loss: {history_no_gc.history['loss'][-1]}\") print(f\"Accuracy: {history_no_gc.history['accuracy'][-1]}\") print(f\"Training Time: {sum(time_callback_no_gc.times)}\") print(\"Using Gradient Centralization\") print(f\"Loss: {history_gc.history['loss'][-1]}\") print(f\"Accuracy: {history_gc.history['accuracy'][-1]}\") print(f\"Training Time: {sum(time_callback_gc.times)}\") Not using Gradient Centralization Loss: 0.5814347863197327 Accuracy: 0.6932814121246338 Training Time: 136.35903406143188 Using Gradient Centralization Loss: 0.4444807469844818 Accuracy: 0.7935734987258911 Training Time: 131.61780261993408 Readers are encouraged to try out Gradient Centralization on different datasets from different domains and experiment with it's effect. You are strongly advised to check out the original paper as well - the authors present several studies on Gradient Centralization showing how it can improve general performance, generalization, training time as well as more efficient. Many thanks to Ali Mustufa Shaikh for reviewing this implementation. Training a handwriting recognition model with variable-length sequences. Introduction This example shows how the Captcha OCR example can be extended to the IAM Dataset, which has variable length ground-truth targets. Each sample in the dataset is an image of some handwritten text, and its corresponding target is the string present in the image. The IAM Dataset is widely used across many OCR benchmarks, so we hope this example can serve as a good starting point for building OCR systems. Data collection !wget -q https://git.io/J0fjL -O IAM_Words.zip !unzip -qq IAM_Words.zip ! !mkdir data !mkdir data/words !tar -xf IAM_Words/words.tgz -C data/words !mv IAM_Words/words.txt data Preview how the dataset is organized. Lines prepended by \"#\" are just metadata information. !head -20 data/words.txt #--- words.txt ---------------------------------------------------------------# # # iam database word information # # format: a01-000u-00-00 ok 154 1 408 768 27 51 AT A # # a01-000u-00-00 -> word id for line 00 in form a01-000u # ok -> result of word segmentation # ok: word was correctly # er: segmentation of word can be bad # # 154 -> graylevel to binarize the line containing this word # 1 -> number of components for this word # 408 768 27 51 -> bounding box around this word in x,y,w,h format # AT -> the grammatical tag for this word, see the # file tagset.txt for an explanation # A -> the transcription for this word # a01-000u-00-00 ok 154 408 768 27 51 AT A a01-000u-00-01 ok 154 507 766 213 48 NN MOVE Imports from tensorflow.keras.layers.experimental.preprocessing import StringLookup from tensorflow import keras import matplotlib.pyplot as plt import tensorflow as tf import numpy as np import os np.random.seed(42) tf.random.set_seed(42) Dataset splitting base_path = \"data\" words_list = [] words = open(f\"{base_path}/words.txt\", \"r\").readlines() for line in words: if line[0] == \"#\": continue if line.split(\" \")[1] != \"err\": # We don't need to deal with errored entries. words_list.append(line) len(words_list) np.random.shuffle(words_list) We will split the dataset into three subsets with a 90:5:5 ratio (train:validation:test). split_idx = int(0.9 * len(words_list)) train_samples = words_list[:split_idx] test_samples = words_list[split_idx:] val_split_idx = int(0.5 * len(test_samples)) validation_samples = test_samples[:val_split_idx] test_samples = test_samples[val_split_idx:] assert len(words_list) == len(train_samples) + len(validation_samples) + len( test_samples ) print(f\"Total training samples: {len(train_samples)}\") print(f\"Total validation samples: {len(validation_samples)}\") print(f\"Total test samples: {len(test_samples)}\") Total training samples: 86810 Total validation samples: 4823 Total test samples: 4823 Data input pipeline We start building our data input pipeline by first preparing the image paths. base_image_path = os.path.join(base_path, \"words\") def get_image_paths_and_labels(samples): paths = [] corrected_samples = [] for (i, file_line) in enumerate(samples): line_split = file_line.strip() line_split = line_split.split(\" \") # Each line split will have this format for the corresponding image: # part1/part1-part2/part1-part2-part3.png image_name = line_split[0] partI = image_name.split(\"-\")[0] partII = image_name.split(\"-\")[1] img_path = os.path.join( base_image_path, partI, partI + \"-\" + partII, image_name + \".png\" ) if os.path.getsize(img_path): paths.append(img_path) corrected_samples.append(file_line.split(\"\n\")[0]) return paths, corrected_samples train_img_paths, train_labels = get_image_paths_and_labels(train_samples) validation_img_paths, validation_labels = get_image_paths_and_labels(validation_samples) test_img_paths, test_labels = get_image_paths_and_labels(test_samples) Then we prepare the ground-truth labels. # Find maximum length and the size of the vocabulary in the training data. train_labels_cleaned = [] characters = set() max_len = 0 for label in train_labels: label = label.split(\" \")[-1].strip() for char in label: characters.add(char) max_len = max(max_len, len(label)) train_labels_cleaned.append(label) print(\"Maximum length: \", max_len) print(\"Vocab size: \", len(characters)) # Check some label samples. train_labels_cleaned[:10] Maximum length: 21 Vocab size: 78 ['sure', 'he', 'during', 'of', 'booty', 'gastronomy', 'boy', 'The', 'and', 'in'] Now we clean the validation and the test labels as well. def clean_labels(labels): cleaned_labels = [] for label in labels: label = label.split(\" \")[-1].strip() cleaned_labels.append(label) return cleaned_labels validation_labels_cleaned = clean_labels(validation_labels) test_labels_cleaned = clean_labels(test_labels) Building the character vocabulary Keras provides different preprocessing layers to deal with different modalities of data. This guide provids a comprehensive introduction. Our example involves preprocessing labels at the character level. This means that if there are two labels, e.g. \"cat\" and \"dog\", then our character vocabulary should be {a, c, d, g, o, t} (without any special tokens). We use the StringLookup layer for this purpose. AUTOTUNE = tf.data.AUTOTUNE # Mapping characters to integers. char_to_num = StringLookup(vocabulary=list(characters), mask_token=None) # Mapping integers back to original characters. num_to_char = StringLookup( vocabulary=char_to_num.get_vocabulary(), mask_token=None, invert=True ) Resizing images without distortion Instead of square images, many OCR models work with rectangular images. This will become clearer in a moment when we will visualize a few samples from the dataset. While aspect-unaware resizing square images does not introduce a significant amount of distortion this is not the case for rectangular images. But resizing images to a uniform size is a requirement for mini-batching. So we need to perform our resizing such that the following criteria are met: Aspect ratio is preserved. Content of the images is not affected. def distortion_free_resize(image, img_size): w, h = img_size image = tf.image.resize(image, size=(h, w), preserve_aspect_ratio=True) # Check tha amount of padding needed to be done. pad_height = h - tf.shape(image)[0] pad_width = w - tf.shape(image)[1] # Only necessary if you want to do same amount of padding on both sides. if pad_height % 2 != 0: height = pad_height // 2 pad_height_top = height + 1 pad_height_bottom = height else: pad_height_top = pad_height_bottom = pad_height // 2 if pad_width % 2 != 0: width = pad_width // 2 pad_width_left = width + 1 pad_width_right = width else: pad_width_left = pad_width_right = pad_width // 2 image = tf.pad( image, paddings=[ [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0, 0], ], ) image = tf.transpose(image, perm=[1, 0, 2]) image = tf.image.flip_left_right(image) return image If we just go with the plain resizing then the images would look like so: Notice how this resizing would have introduced unnecessary stretching. Putting the utilities together batch_size = 64 padding_token = 99 image_width = 128 image_height = 32 def preprocess_image(image_path, img_size=(image_width, image_height)): image = tf.io.read_file(image_path) image = tf.image.decode_png(image, 1) image = distortion_free_resize(image, img_size) image = tf.cast(image, tf.float32) / 255.0 return image def vectorize_label(label): label = char_to_num(tf.strings.unicode_split(label, input_encoding=\"UTF-8\")) length = tf.shape(label)[0] pad_amount = max_len - length label = tf.pad(label, paddings=[[0, pad_amount]], constant_values=padding_token) return label def process_images_labels(image_path, label): image = preprocess_image(image_path) label = vectorize_label(label) return {\"image\": image, \"label\": label} def prepare_dataset(image_paths, labels): dataset = tf.data.Dataset.from_tensor_slices((image_paths, labels)).map( process_images_labels, num_parallel_calls=AUTOTUNE ) return dataset.batch(batch_size).cache().prefetch(AUTOTUNE) Prepare tf.data.Dataset objects train_ds = prepare_dataset(train_img_paths, train_labels_cleaned) validation_ds = prepare_dataset(validation_img_paths, validation_labels_cleaned) test_ds = prepare_dataset(test_img_paths, test_labels_cleaned) Visualize a few samples for data in train_ds.take(1): images, labels = data[\"image\"], data[\"label\"] _, ax = plt.subplots(4, 4, figsize=(15, 8)) for i in range(16): img = images[i] img = tf.image.flip_left_right(img) img = tf.transpose(img, perm=[1, 0, 2]) img = (img * 255.0).numpy().clip(0, 255).astype(np.uint8) img = img[:, :, 0] # Gather indices where label!= padding_token. label = labels[i] indices = tf.gather(label, tf.where(tf.math.not_equal(label, padding_token))) # Convert to string. label = tf.strings.reduce_join(num_to_char(indices)) label = label.numpy().decode(\"utf-8\") ax[i // 4, i % 4].imshow(img, cmap=\"gray\") ax[i // 4, i % 4].set_title(label) ax[i // 4, i % 4].axis(\"off\") plt.show() png You will notice that the content of original image is kept as faithful as possible and has been padded accordingly. Model Our model will use the CTC loss as an endpoint layer. For a detailed understanding of the CTC loss, refer to this post. class CTCLayer(keras.layers.Layer): def __init__(self, name=None): super().__init__(name=name) self.loss_fn = keras.backend.ctc_batch_cost def call(self, y_true, y_pred): batch_len = tf.cast(tf.shape(y_true)[0], dtype=\"int64\") input_length = tf.cast(tf.shape(y_pred)[1], dtype=\"int64\") label_length = tf.cast(tf.shape(y_true)[1], dtype=\"int64\") input_length = input_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\") label_length = label_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\") loss = self.loss_fn(y_true, y_pred, input_length, label_length) self.add_loss(loss) # At test time, just return the computed predictions. return y_pred def build_model(): # Inputs to the model input_img = keras.Input(shape=(image_width, image_height, 1), name=\"image\") labels = keras.layers.Input(name=\"label\", shape=(None,)) # First conv block. x = keras.layers.Conv2D( 32, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\", name=\"Conv1\", )(input_img) x = keras.layers.MaxPooling2D((2, 2), name=\"pool1\")(x) # Second conv block. x = keras.layers.Conv2D( 64, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\", name=\"Conv2\", )(x) x = keras.layers.MaxPooling2D((2, 2), name=\"pool2\")(x) # We have used two max pool with pool size and strides 2. # Hence, downsampled feature maps are 4x smaller. The number of # filters in the last layer is 64. Reshape accordingly before # passing the output to the RNN part of the model. new_shape = ((image_width // 4), (image_height // 4) * 64) x = keras.layers.Reshape(target_shape=new_shape, name=\"reshape\")(x) x = keras.layers.Dense(64, activation=\"relu\", name=\"dense1\")(x) x = keras.layers.Dropout(0.2)(x) # RNNs. x = keras.layers.Bidirectional( keras.layers.LSTM(128, return_sequences=True, dropout=0.25) )(x) x = keras.layers.Bidirectional( keras.layers.LSTM(64, return_sequences=True, dropout=0.25) )(x) # +2 is to account for the two special tokens introduced by the CTC loss. # The recommendation comes here: https://git.io/J0eXP. x = keras.layers.Dense( len(char_to_num.get_vocabulary()) + 2, activation=\"softmax\", name=\"dense2\" )(x) # Add CTC layer for calculating CTC loss at each step. output = CTCLayer(name=\"ctc_loss\")(labels, x) # Define the model. model = keras.models.Model( inputs=[input_img, labels], outputs=output, name=\"handwriting_recognizer\" ) # Optimizer. opt = keras.optimizers.Adam() # Compile the model and return. model.compile(optimizer=opt) return model # Get the model. model = build_model() model.summary() Model: \"handwriting_recognizer\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== image (InputLayer) [(None, 128, 32, 1)] 0 __________________________________________________________________________________________________ Conv1 (Conv2D) (None, 128, 32, 32) 320 image[0][0] __________________________________________________________________________________________________ pool1 (MaxPooling2D) (None, 64, 16, 32) 0 Conv1[0][0] __________________________________________________________________________________________________ Conv2 (Conv2D) (None, 64, 16, 64) 18496 pool1[0][0] __________________________________________________________________________________________________ pool2 (MaxPooling2D) (None, 32, 8, 64) 0 Conv2[0][0] __________________________________________________________________________________________________ reshape (Reshape) (None, 32, 512) 0 pool2[0][0] __________________________________________________________________________________________________ dense1 (Dense) (None, 32, 64) 32832 reshape[0][0] __________________________________________________________________________________________________ dropout (Dropout) (None, 32, 64) 0 dense1[0][0] __________________________________________________________________________________________________ bidirectional (Bidirectional) (None, 32, 256) 197632 dropout[0][0] __________________________________________________________________________________________________ bidirectional_1 (Bidirectional) (None, 32, 128) 164352 bidirectional[0][0] __________________________________________________________________________________________________ label (InputLayer) [(None, None)] 0 __________________________________________________________________________________________________ dense2 (Dense) (None, 32, 81) 10449 bidirectional_1[0][0] __________________________________________________________________________________________________ ctc_loss (CTCLayer) (None, 32, 81) 0 label[0][0] dense2[0][0] ================================================================================================== Total params: 424,081 Trainable params: 424,081 Non-trainable params: 0 __________________________________________________________________________________________________ Evaluation metric Edit Distance is the most widely used metric for evaluating OCR models. In this section, we will implement it and use it as a callback to monitor our model. We first segregate the validation images and their labels for convenience. validation_images = [] validation_labels = [] for batch in validation_ds: validation_images.append(batch[\"image\"]) validation_labels.append(batch[\"label\"]) Now, we create a callback to monitor the edit distances. def calculate_edit_distance(labels, predictions): # Get a single batch and convert its labels to sparse tensors. saprse_labels = tf.cast(tf.sparse.from_dense(labels), dtype=tf.int64) # Make predictions and convert them to sparse tensors. input_len = np.ones(predictions.shape[0]) * predictions.shape[1] predictions_decoded = keras.backend.ctc_decode( predictions, input_length=input_len, greedy=True )[0][0][:, :max_len] sparse_predictions = tf.cast( tf.sparse.from_dense(predictions_decoded), dtype=tf.int64 ) # Compute individual edit distances and average them out. edit_distances = tf.edit_distance( sparse_predictions, saprse_labels, normalize=False ) return tf.reduce_mean(edit_distances) class EditDistanceCallback(keras.callbacks.Callback): def __init__(self, pred_model): super().__init__() self.prediction_model = pred_model def on_epoch_end(self, epoch, logs=None): edit_distances = [] for i in range(len(validation_images)): labels = validation_labels[i] predictions = self.prediction_model.predict(validation_images[i]) edit_distances.append(calculate_edit_distance(labels, predictions).numpy()) print( f\"Mean edit distance for epoch {epoch + 1}: {np.mean(edit_distances):.4f}\" ) Training Now we are ready to kick off model training. epochs = 10 # To get good results this should be at least 50. model = build_model() prediction_model = keras.models.Model( model.get_layer(name=\"image\").input, model.get_layer(name=\"dense2\").output ) edit_distance_callback = EditDistanceCallback(prediction_model) # Train the model. history = model.fit( train_ds, validation_data=validation_ds, epochs=epochs, callbacks=[edit_distance_callback], ) Epoch 1/10 1357/1357 [==============================] - 89s 51ms/step - loss: 13.6670 - val_loss: 11.8041 Mean edit distance for epoch 1: 20.5117 Epoch 2/10 1357/1357 [==============================] - 48s 36ms/step - loss: 10.6864 - val_loss: 9.6994 Mean edit distance for epoch 2: 20.1167 Epoch 3/10 1357/1357 [==============================] - 48s 35ms/step - loss: 9.0437 - val_loss: 8.0355 Mean edit distance for epoch 3: 19.7270 Epoch 4/10 1357/1357 [==============================] - 48s 35ms/step - loss: 7.6098 - val_loss: 6.4239 Mean edit distance for epoch 4: 19.1106 Epoch 5/10 1357/1357 [==============================] - 48s 35ms/step - loss: 6.3194 - val_loss: 4.9814 Mean edit distance for epoch 5: 18.4894 Epoch 6/10 1357/1357 [==============================] - 48s 35ms/step - loss: 5.3417 - val_loss: 4.1307 Mean edit distance for epoch 6: 18.1909 Epoch 7/10 1357/1357 [==============================] - 48s 35ms/step - loss: 4.6396 - val_loss: 3.7706 Mean edit distance for epoch 7: 18.1224 Epoch 8/10 1357/1357 [==============================] - 48s 35ms/step - loss: 4.1926 - val_loss: 3.3682 Mean edit distance for epoch 8: 17.9387 Epoch 9/10 1357/1357 [==============================] - 48s 36ms/step - loss: 3.8532 - val_loss: 3.1829 Mean edit distance for epoch 9: 17.9074 Epoch 10/10 1357/1357 [==============================] - 49s 36ms/step - loss: 3.5769 - val_loss: 2.9221 Mean edit distance for epoch 10: 17.7960 Inference # A utility function to decode the output of the network. def decode_batch_predictions(pred): input_len = np.ones(pred.shape[0]) * pred.shape[1] # Use greedy search. For complex tasks, you can use beam search. results = keras.backend.ctc_decode(pred, input_length=input_len, greedy=True)[0][0][ :, :max_len ] # Iterate over the results and get back the text. output_text = [] for res in results: res = tf.gather(res, tf.where(tf.math.not_equal(res, -1))) res = tf.strings.reduce_join(num_to_char(res)).numpy().decode(\"utf-8\") output_text.append(res) return output_text # Let's check results on some test samples. for batch in test_ds.take(1): batch_images = batch[\"image\"] _, ax = plt.subplots(4, 4, figsize=(15, 8)) preds = prediction_model.predict(batch_images) pred_texts = decode_batch_predictions(preds) for i in range(16): img = batch_images[i] img = tf.image.flip_left_right(img) img = tf.transpose(img, perm=[1, 0, 2]) img = (img * 255.0).numpy().clip(0, 255).astype(np.uint8) img = img[:, :, 0] title = f\"Prediction: {pred_texts[i]}\" ax[i // 4, i % 4].imshow(img, cmap=\"gray\") ax[i // 4, i % 4].set_title(title) ax[i // 4, i % 4].axis(\"off\") plt.show() png To get better results the model should be trained for at least 50 epochs. Final remarks The prediction_model is fully compatible with TensorFlow Lite. If you are interested, you can use it inside a mobile application. You may find this notebook to be useful in this regard. Not all the training examples are perfectly aligned as observed in this example. This can hurt model performance for complex sequences. To this end, we can leverage Spatial Transformer Networks (Jaderberg et al.) that can help the model learn affine transformations that maximize its performance. Implement an image captioning model using a CNN and a Transformer. Setup import os import re import numpy as np import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.applications import efficientnet from tensorflow.keras.layers import TextVectorization seed = 111 np.random.seed(seed) tf.random.set_seed(seed) Download the dataset We will be using the Flickr8K dataset for this tutorial. This dataset comprises over 8,000 images, that are each paired with five different captions. !wget -q https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_Dataset.zip !wget -q https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_text.zip !unzip -qq Flickr8k_Dataset.zip !unzip -qq Flickr8k_text.zip !rm Flickr8k_Dataset.zip Flickr8k_text.zip # Path to the images IMAGES_PATH = \"Flicker8k_Dataset\" # Desired image dimensions IMAGE_SIZE = (299, 299) # Vocabulary size VOCAB_SIZE = 10000 # Fixed length allowed for any sequence SEQ_LENGTH = 25 # Dimension for the image embeddings and token embeddings EMBED_DIM = 512 # Per-layer units in the feed-forward network FF_DIM = 512 # Other training parameters BATCH_SIZE = 64 EPOCHS = 30 AUTOTUNE = tf.data.AUTOTUNE Preparing the dataset def load_captions_data(filename): \"\"\"Loads captions (text) data and maps them to corresponding images. Args: filename: Path to the text file containing caption data. Returns: caption_mapping: Dictionary mapping image names and the corresponding captions text_data: List containing all the available captions \"\"\" with open(filename) as caption_file: caption_data = caption_file.readlines() caption_mapping = {} text_data = [] images_to_skip = set() for line in caption_data: line = line.rstrip(\"\n\") # Image name and captions are separated using a tab img_name, caption = line.split(\"\t\") # Each image is repeated five times for the five different captions. # Each image name has a suffix `#(caption_number)` img_name = img_name.split(\"#\")[0] img_name = os.path.join(IMAGES_PATH, img_name.strip()) # We will remove caption that are either too short to too long tokens = caption.strip().split() if len(tokens) < 5 or len(tokens) > SEQ_LENGTH: images_to_skip.add(img_name) continue if img_name.endswith(\"jpg\") and img_name not in images_to_skip: # We will add a start and an end token to each caption caption = \" \" + caption.strip() + \" \" text_data.append(caption) if img_name in caption_mapping: caption_mapping[img_name].append(caption) else: caption_mapping[img_name] = [caption] for img_name in images_to_skip: if img_name in caption_mapping: del caption_mapping[img_name] return caption_mapping, text_data def train_val_split(caption_data, train_size=0.8, shuffle=True): \"\"\"Split the captioning dataset into train and validation sets. Args: caption_data (dict): Dictionary containing the mapped caption data train_size (float): Fraction of all the full dataset to use as training data shuffle (bool): Whether to shuffle the dataset before splitting Returns: Traning and validation datasets as two separated dicts \"\"\" # 1. Get the list of all image names all_images = list(caption_data.keys()) # 2. Shuffle if necessary if shuffle: np.random.shuffle(all_images) # 3. Split into training and validation sets train_size = int(len(caption_data) * train_size) training_data = { img_name: caption_data[img_name] for img_name in all_images[:train_size] } validation_data = { img_name: caption_data[img_name] for img_name in all_images[train_size:] } # 4. Return the splits return training_data, validation_data # Load the dataset captions_mapping, text_data = load_captions_data(\"Flickr8k.token.txt\") # Split the dataset into training and validation sets train_data, valid_data = train_val_split(captions_mapping) print(\"Number of training samples: \", len(train_data)) print(\"Number of validation samples: \", len(valid_data)) Number of training samples: 6114 Number of validation samples: 1529 Number of training samples: 6114 Number of validation samples: 1529 Vectorizing the text data We'll use the TextVectorization layer to vectorize the text data, that is to say, to turn the original strings into integer sequences where each integer represents the index of a word in a vocabulary. We will use a custom string standardization scheme (strip punctuation characters except < and >) and the default splitting scheme (split on whitespace). def custom_standardization(input_string): lowercase = tf.strings.lower(input_string) return tf.strings.regex_replace(lowercase, \"[%s]\" % re.escape(strip_chars), \"\") # [KERASBERT PROCESSING] removed definition of special chars for import strip_chars = strip_chars.replace(\"<\", \"\") strip_chars = strip_chars.replace(\">\", \"\") vectorization = TextVectorization( max_tokens=VOCAB_SIZE, output_mode=\"int\", output_sequence_length=SEQ_LENGTH, standardize=custom_standardization, ) vectorization.adapt(text_data) # Data augmentation for image data image_augmentation = keras.Sequential( [ layers.RandomFlip(\"horizontal\"), layers.RandomRotation(0.2), layers.RandomContrast(0.3), ] ) 2021-09-17 05:17:57.047819: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.058177: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.106007: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.107650: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. 2021-09-17 05:17:57.134387: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.135154: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.135806: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.680010: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.680785: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.681439: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-17 05:17:57.682067: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14684 MB memory: -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:04.0, compute capability: 7.0 2021-09-17 05:17:58.229404: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2) Building a tf.data.Dataset pipeline for training We will generate pairs of images and corresponding captions using a tf.data.Dataset object. The pipeline consists of two steps: Read the image from the disk Tokenize all the five captions corresponding to the image def decode_and_resize(img_path): img = tf.io.read_file(img_path) img = tf.image.decode_jpeg(img, channels=3) img = tf.image.resize(img, IMAGE_SIZE) img = tf.image.convert_image_dtype(img, tf.float32) return img def process_input(img_path, captions): return decode_and_resize(img_path), vectorization(captions) def make_dataset(images, captions): if split == \"train\": img_dataset = tf.data.Dataset.from_tensor_slices(images).map( read_train_image, num_parallel_calls=AUTOTUNE ) else: img_dataset = tf.data.Dataset.from_tensor_slices(images).map( read_valid_image, num_parallel_calls=AUTOTUNE ) cap_dataset = tf.data.Dataset.from_tensor_slices(captions).map( vectorization, num_parallel_calls=AUTOTUNE ) dataset = tf.data.Dataset.zip((img_dataset, cap_dataset)) dataset = dataset.batch(BATCH_SIZE).shuffle(256).prefetch(AUTOTUNE) return dataset # Pass the list of images and the list of corresponding captions train_dataset = make_dataset(list(train_data.keys()), list(train_data.values())) valid_dataset = make_dataset(list(valid_data.keys()), list(valid_data.values())) Building the model Our image captioning architecture consists of three models: A CNN: used to extract the image features A TransformerEncoder: The extracted image features are then passed to a Transformer based encoder that generates a new representation of the inputs A TransformerDecoder: This model takes the encoder output and the text data (sequences) as inputs and tries to learn to generate the caption. def get_cnn_model(): base_model = efficientnet.EfficientNetB0( input_shape=(*IMAGE_SIZE, 3), include_top=False, weights=\"imagenet\", ) # We freeze our feature extractor base_model.trainable = False base_model_out = base_model.output base_model_out = layers.Reshape((-1, base_model_out.shape[-1]))(base_model_out) cnn_model = keras.models.Model(base_model.input, base_model_out) return cnn_model class TransformerEncoderBlock(layers.Layer): def __init__(self, embed_dim, dense_dim, num_heads, **kwargs): super().__init__(**kwargs) self.embed_dim = embed_dim self.dense_dim = dense_dim self.num_heads = num_heads self.attention_1 = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim, dropout=0.0 ) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() self.dense_1 = layers.Dense(embed_dim, activation=\"relu\") def call(self, inputs, training, mask=None): inputs = self.layernorm_1(inputs) inputs = self.dense_1(inputs) attention_output_1 = self.attention_1( query=inputs, value=inputs, key=inputs, attention_mask=None, training=training, ) out_1 = self.layernorm_2(inputs + attention_output_1) return out_1 class PositionalEmbedding(layers.Layer): def __init__(self, sequence_length, vocab_size, embed_dim, **kwargs): super().__init__(**kwargs) self.token_embeddings = layers.Embedding( input_dim=vocab_size, output_dim=embed_dim ) self.position_embeddings = layers.Embedding( input_dim=sequence_length, output_dim=embed_dim ) self.sequence_length = sequence_length self.vocab_size = vocab_size self.embed_dim = embed_dim self.embed_scale = tf.math.sqrt(tf.cast(embed_dim, tf.float32)) def call(self, inputs): length = tf.shape(inputs)[-1] positions = tf.range(start=0, limit=length, delta=1) embedded_tokens = self.token_embeddings(inputs) embedded_tokens = embedded_tokens * self.embed_scale embedded_positions = self.position_embeddings(positions) return embedded_tokens + embedded_positions def compute_mask(self, inputs, mask=None): return tf.math.not_equal(inputs, 0) class TransformerDecoderBlock(layers.Layer): def __init__(self, embed_dim, ff_dim, num_heads, **kwargs): super().__init__(**kwargs) self.embed_dim = embed_dim self.ff_dim = ff_dim self.num_heads = num_heads self.attention_1 = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim, dropout=0.1 ) self.attention_2 = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim, dropout=0.1 ) self.ffn_layer_1 = layers.Dense(ff_dim, activation=\"relu\") self.ffn_layer_2 = layers.Dense(embed_dim) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() self.layernorm_3 = layers.LayerNormalization() self.embedding = PositionalEmbedding( embed_dim=EMBED_DIM, sequence_length=SEQ_LENGTH, vocab_size=VOCAB_SIZE ) self.out = layers.Dense(VOCAB_SIZE, activation=\"softmax\") self.dropout_1 = layers.Dropout(0.3) self.dropout_2 = layers.Dropout(0.5) self.supports_masking = True def call(self, inputs, encoder_outputs, training, mask=None): inputs = self.embedding(inputs) causal_mask = self.get_causal_attention_mask(inputs) if mask is not None: padding_mask = tf.cast(mask[:, :, tf.newaxis], dtype=tf.int32) combined_mask = tf.cast(mask[:, tf.newaxis, :], dtype=tf.int32) combined_mask = tf.minimum(combined_mask, causal_mask) attention_output_1 = self.attention_1( query=inputs, value=inputs, key=inputs, attention_mask=combined_mask, training=training, ) out_1 = self.layernorm_1(inputs + attention_output_1) attention_output_2 = self.attention_2( query=out_1, value=encoder_outputs, key=encoder_outputs, attention_mask=padding_mask, training=training, ) out_2 = self.layernorm_2(out_1 + attention_output_2) ffn_out = self.ffn_layer_1(out_2) ffn_out = self.dropout_1(ffn_out, training=training) ffn_out = self.ffn_layer_2(ffn_out) ffn_out = self.layernorm_3(ffn_out + out_2, training=training) ffn_out = self.dropout_2(ffn_out, training=training) preds = self.out(ffn_out) return preds def get_causal_attention_mask(self, inputs): input_shape = tf.shape(inputs) batch_size, sequence_length = input_shape[0], input_shape[1] i = tf.range(sequence_length)[:, tf.newaxis] j = tf.range(sequence_length) mask = tf.cast(i >= j, dtype=\"int32\") mask = tf.reshape(mask, (1, input_shape[1], input_shape[1])) mult = tf.concat( [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)], axis=0, ) return tf.tile(mask, mult) class ImageCaptioningModel(keras.Model): def __init__( self, cnn_model, encoder, decoder, num_captions_per_image=5, image_aug=None, ): super().__init__() self.cnn_model = cnn_model self.encoder = encoder self.decoder = decoder self.loss_tracker = keras.metrics.Mean(name=\"loss\") self.acc_tracker = keras.metrics.Mean(name=\"accuracy\") self.num_captions_per_image = num_captions_per_image self.image_aug = image_aug def calculate_loss(self, y_true, y_pred, mask): loss = self.loss(y_true, y_pred) mask = tf.cast(mask, dtype=loss.dtype) loss *= mask return tf.reduce_sum(loss) / tf.reduce_sum(mask) def calculate_accuracy(self, y_true, y_pred, mask): accuracy = tf.equal(y_true, tf.argmax(y_pred, axis=2)) accuracy = tf.math.logical_and(mask, accuracy) accuracy = tf.cast(accuracy, dtype=tf.float32) mask = tf.cast(mask, dtype=tf.float32) return tf.reduce_sum(accuracy) / tf.reduce_sum(mask) def _compute_caption_loss_and_acc(self, img_embed, batch_seq, training=True): encoder_out = self.encoder(img_embed, training=training) batch_seq_inp = batch_seq[:, :-1] batch_seq_true = batch_seq[:, 1:] mask = tf.math.not_equal(batch_seq_true, 0) batch_seq_pred = self.decoder( batch_seq_inp, encoder_out, training=training, mask=mask ) loss = self.calculate_loss(batch_seq_true, batch_seq_pred, mask) acc = self.calculate_accuracy(batch_seq_true, batch_seq_pred, mask) return loss, acc def train_step(self, batch_data): batch_img, batch_seq = batch_data batch_loss = 0 batch_acc = 0 if self.image_aug: batch_img = self.image_aug(batch_img) # 1. Get image embeddings img_embed = self.cnn_model(batch_img) # 2. Pass each of the five captions one by one to the decoder # along with the encoder outputs and compute the loss as well as accuracy # for each caption. for i in range(self.num_captions_per_image): with tf.GradientTape() as tape: loss, acc = self._compute_caption_loss_and_acc( img_embed, batch_seq[:, i, :], training=True ) # 3. Update loss and accuracy batch_loss += loss batch_acc += acc # 4. Get the list of all the trainable weights train_vars = ( self.encoder.trainable_variables + self.decoder.trainable_variables ) # 5. Get the gradients grads = tape.gradient(loss, train_vars) # 6. Update the trainable weights self.optimizer.apply_gradients(zip(grads, train_vars)) # 7. Update the trackers batch_acc /= float(self.num_captions_per_image) self.loss_tracker.update_state(batch_loss) self.acc_tracker.update_state(batch_acc) # 8. Return the loss and accuracy values return {\"loss\": self.loss_tracker.result(), \"acc\": self.acc_tracker.result()} def test_step(self, batch_data): batch_img, batch_seq = batch_data batch_loss = 0 batch_acc = 0 # 1. Get image embeddings img_embed = self.cnn_model(batch_img) # 2. Pass each of the five captions one by one to the decoder # along with the encoder outputs and compute the loss as well as accuracy # for each caption. for i in range(self.num_captions_per_image): loss, acc = self._compute_caption_loss_and_acc( img_embed, batch_seq[:, i, :], training=False ) # 3. Update batch loss and batch accuracy batch_loss += loss batch_acc += acc batch_acc /= float(self.num_captions_per_image) # 4. Update the trackers self.loss_tracker.update_state(batch_loss) self.acc_tracker.update_state(batch_acc) # 5. Return the loss and accuracy values return {\"loss\": self.loss_tracker.result(), \"acc\": self.acc_tracker.result()} @property def metrics(self): # We need to list our metrics here so the `reset_states()` can be # called automatically. return [self.loss_tracker, self.acc_tracker] cnn_model = get_cnn_model() encoder = TransformerEncoderBlock(embed_dim=EMBED_DIM, dense_dim=FF_DIM, num_heads=1) decoder = TransformerDecoderBlock(embed_dim=EMBED_DIM, ff_dim=FF_DIM, num_heads=2) caption_model = ImageCaptioningModel( cnn_model=cnn_model, encoder=encoder, decoder=decoder, image_aug=image_augmentation, ) Model training # Define the loss function cross_entropy = keras.losses.SparseCategoricalCrossentropy( from_logits=False, reduction=\"none\" ) # EarlyStopping criteria early_stopping = keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True) # Learning Rate Scheduler for the optimizer class LRSchedule(keras.optimizers.schedules.LearningRateSchedule): def __init__(self, post_warmup_learning_rate, warmup_steps): super().__init__() self.post_warmup_learning_rate = post_warmup_learning_rate self.warmup_steps = warmup_steps def __call__(self, step): global_step = tf.cast(step, tf.float32) warmup_steps = tf.cast(self.warmup_steps, tf.float32) warmup_progress = global_step / warmup_steps warmup_learning_rate = self.post_warmup_learning_rate * warmup_progress return tf.cond( global_step < warmup_steps, lambda: warmup_learning_rate, lambda: self.post_warmup_learning_rate, ) # Create a learning rate schedule num_train_steps = len(train_dataset) * EPOCHS num_warmup_steps = num_train_steps // 15 lr_schedule = LRSchedule(post_warmup_learning_rate=1e-4, warmup_steps=num_warmup_steps) # Compile the model caption_model.compile(optimizer=keras.optimizers.Adam(lr_schedule), loss=cross_entropy) # Fit the model caption_model.fit( train_dataset, epochs=EPOCHS, validation_data=valid_dataset, callbacks=[early_stopping], ) Epoch 1/30 2021-09-17 05:18:22.943796: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 59 of 256 2021-09-17 05:18:30.137746: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 2021-09-17 05:18:30.598020: I tensorflow/stream_executor/cuda/cuda_dnn.cc:369] Loaded cuDNN version 8005 96/96 [==============================] - 62s 327ms/step - loss: 28.1409 - acc: 0.1313 - val_loss: 20.4968 - val_acc: 0.3116 Epoch 2/30 2021-09-17 05:19:13.829127: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 59 of 256 2021-09-17 05:19:19.872802: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 43s 278ms/step - loss: 19.3393 - acc: 0.3207 - val_loss: 18.0922 - val_acc: 0.3514 Epoch 3/30 2021-09-17 05:19:56.772506: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 61 of 256 2021-09-17 05:20:02.481758: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 278ms/step - loss: 17.4184 - acc: 0.3552 - val_loss: 17.0022 - val_acc: 0.3698 Epoch 4/30 2021-09-17 05:20:39.367542: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 61 of 256 2021-09-17 05:20:45.149089: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 43s 278ms/step - loss: 16.3052 - acc: 0.3760 - val_loss: 16.3026 - val_acc: 0.3845 Epoch 5/30 2021-09-17 05:21:21.930582: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 61 of 256 2021-09-17 05:21:27.608503: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 278ms/step - loss: 15.5097 - acc: 0.3901 - val_loss: 15.8929 - val_acc: 0.3925 Epoch 6/30 2021-09-17 05:22:04.553717: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 61 of 256 2021-09-17 05:22:10.210087: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 278ms/step - loss: 14.8596 - acc: 0.4069 - val_loss: 15.5456 - val_acc: 0.4005 Epoch 7/30 2021-09-17 05:22:47.100594: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 62 of 256 2021-09-17 05:22:52.466539: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 14.3454 - acc: 0.4131 - val_loss: 15.3313 - val_acc: 0.4045 Epoch 8/30 2021-09-17 05:23:29.226300: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 61 of 256 2021-09-17 05:23:34.808841: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 13.8745 - acc: 0.4251 - val_loss: 15.2011 - val_acc: 0.4078 Epoch 9/30 2021-09-17 05:24:11.615058: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 62 of 256 2021-09-17 05:24:17.030769: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 13.4640 - acc: 0.4350 - val_loss: 15.0905 - val_acc: 0.4107 Epoch 10/30 2021-09-17 05:24:53.832807: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 61 of 256 2021-09-17 05:24:59.506573: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 13.0922 - acc: 0.4414 - val_loss: 15.0083 - val_acc: 0.4113 Epoch 11/30 2021-09-17 05:25:36.242501: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 62 of 256 2021-09-17 05:25:41.723206: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 12.7538 - acc: 0.4464 - val_loss: 14.9455 - val_acc: 0.4143 Epoch 12/30 2021-09-17 05:26:18.532009: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 62 of 256 2021-09-17 05:26:23.985106: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 12.4233 - acc: 0.4547 - val_loss: 14.9816 - val_acc: 0.4133 Epoch 13/30 2021-09-17 05:27:00.696082: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 63 of 256 2021-09-17 05:27:05.812571: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 12.1264 - acc: 0.4636 - val_loss: 14.9451 - val_acc: 0.4158 Epoch 14/30 2021-09-17 05:27:42.513445: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 63 of 256 2021-09-17 05:27:47.675342: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 11.8244 - acc: 0.4724 - val_loss: 14.9751 - val_acc: 0.4148 Epoch 15/30 2021-09-17 05:28:24.371225: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 63 of 256 2021-09-17 05:28:29.829654: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 11.5644 - acc: 0.4776 - val_loss: 15.0377 - val_acc: 0.4167 Epoch 16/30 2021-09-17 05:29:06.564650: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:175] Filling up shuffle buffer (this may take a while): 62 of 256 2021-09-17 05:29:11.945996: I tensorflow/core/kernels/data/shuffle_dataset_op.cc:228] Shuffle buffer filled. 96/96 [==============================] - 42s 277ms/step - loss: 11.3046 - acc: 0.4852 - val_loss: 15.0575 - val_acc: 0.4135 Check sample predictions vocab = vectorization.get_vocabulary() index_lookup = dict(zip(range(len(vocab)), vocab)) max_decoded_sentence_length = SEQ_LENGTH - 1 valid_images = list(valid_data.keys()) def generate_caption(): # Select a random image from the validation dataset sample_img = np.random.choice(valid_images) # Read the image from the disk sample_img = decode_and_resize(sample_img) img = sample_img.numpy().clip(0, 255).astype(np.uint8) plt.imshow(img) plt.show() # Pass the image to the CNN img = tf.expand_dims(sample_img, 0) img = caption_model.cnn_model(img) # Pass the image features to the Transformer encoder encoded_img = caption_model.encoder(img, training=False) # Generate the caption using the Transformer decoder decoded_caption = \" \" for i in range(max_decoded_sentence_length): tokenized_caption = vectorization([decoded_caption])[:, :-1] mask = tf.math.not_equal(tokenized_caption, 0) predictions = caption_model.decoder( tokenized_caption, encoded_img, training=False, mask=mask ) sampled_token_index = np.argmax(predictions[0, i, :]) sampled_token = index_lookup[sampled_token_index] if sampled_token == \" \": break decoded_caption += \" \" + sampled_token decoded_caption = decoded_caption.replace(\" \", \"\") decoded_caption = decoded_caption.replace(\" \", \"\").strip() print(\"Predicted Caption: \", decoded_caption) # Check predictions for a few samples generate_caption() generate_caption() generate_caption() png Predicted Caption: a group of dogs race in the snow png Predicted Caption: a man in a blue canoe on a lake png Predicted Caption: a black and white dog is running through a green grass End Notes We saw that the model starts to generate reasonable captions after a few epochs. To keep this example easily runnable, we have trained it with a few constraints, like a minimal number of attention heads. To improve the predictions, you can try changing these training settings and find a good model for your use case. Training an image classifier from scratch on the Kaggle Cats vs Dogs dataset. Introduction This example shows how to do image classification from scratch, starting from JPEG image files on disk, without leveraging pre-trained weights or a pre-made Keras Application model. We demonstrate the workflow on the Kaggle Cats vs Dogs binary classification dataset. We use the image_dataset_from_directory utility to generate the datasets, and we use Keras image preprocessing layers for image standardization and data augmentation. Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Load the data: the Cats vs Dogs dataset Raw data download First, let's download the 786M ZIP archive of the raw data: !curl -O https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip !unzip -q kagglecatsanddogs_3367a.zip !ls % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 786M 100 786M 0 0 44.4M 0 0:00:17 0:00:17 --:--:-- 49.6M image_classification_from_scratch.ipynb MSR-LA - 3467.docx readme[1].txt kagglecatsanddogs_3367a.zip PetImages Now we have a PetImages folder which contain two subfolders, Cat and Dog. Each subfolder contains image files for each category. !ls PetImages Cat Dog Filter out corrupted images When working with lots of real-world image data, corrupted images are a common occurence. Let's filter out badly-encoded images that do not feature the string "JFIF" in their header. import os num_skipped = 0 for folder_name in (\"Cat\", \"Dog\"): folder_path = os.path.join(\"PetImages\", folder_name) for fname in os.listdir(folder_path): fpath = os.path.join(folder_path, fname) try: fobj = open(fpath, \"rb\") is_jfif = tf.compat.as_bytes(\"JFIF\") in fobj.peek(10) finally: fobj.close() if not is_jfif: num_skipped += 1 # Delete corrupted image os.remove(fpath) print(\"Deleted %d images\" % num_skipped) Deleted 1590 images Generate a Dataset image_size = (180, 180) batch_size = 32 train_ds = tf.keras.preprocessing.image_dataset_from_directory( \"PetImages\", validation_split=0.2, subset=\"trainin\", seed=1337, image_size=image_size, batch_size=batch_size, ) val_ds = tf.keras.preprocessing.image_dataset_from_directory( \"PetImages\", validation_split=0.2, subset=\"validation\", seed=1337, image_size=image_size, batch_size=batch_size, ) Found 23410 files belonging to 2 classes. Using 18728 files for training. Found 23410 files belonging to 2 classes. Using 4682 files for validation. Visualize the data Here are the first 9 images in the training dataset. As you can see, label 1 is \"dog\" and label 0 is "cat". import matplotlib.pyplot as plt plt.figure(figsize=(10, 10)) for images, labels in train_ds.take(1): for i in range(9): ax = plt.subplot(3, 3, i + 1) plt.imshow(images[i].numpy().astype(\"uint8\")) plt.title(int(labels[i])) plt.axis(\"off\") png Using image data augmentation When you don't have a large image dataset, it's a good practice to artificially introduce sample diversity by applying random yet realistic transformations to the training images, such as random horizontal flipping or small random rotations. This helps expose the model to different aspects of the training data while slowing down overfitting. data_augmentation = keras.Sequential( [ layers.RandomFlip(\"horizontal\"), layers.RandomRotation(0.1), ] ) Let's visualize what the augmented samples look like, by applying data_augmentation repeatedly to the first image in the dataset: plt.figure(figsize=(10, 10)) for images, _ in train_ds.take(1): for i in range(9): augmented_images = data_augmentation(images) ax = plt.subplot(3, 3, i + 1) plt.imshow(augmented_images[0].numpy().astype(\"uint8\")) plt.axis(\"off\") png Standardizing the data Our image are already in a standard size (180x180), as they are being yielded as contiguous float32 batches by our dataset. However, their RGB channel values are in the [0, 255] range. This is not ideal for a neural network; in general you should seek to make your input values small. Here, we will standardize values to be in the [0, 1] by using a Rescaling layer at the start of our model. Two options to preprocess the data There are two ways you could be using the data_augmentation preprocessor: Option 1: Make it part of the model, like this: inputs = keras.Input(shape=input_shape) x = data_augmentation(inputs) x = layers.Rescaling(1./255)(x) ... # Rest of the model With this option, your data augmentation will happen on device, synchronously with the rest of the model execution, meaning that it will benefit from GPU acceleration. Note that data augmentation is inactive at test time, so the input samples will only be augmented during fit(), not when calling evaluate() or predict(). If you're training on GPU, this is the better option. Option 2: apply it to the dataset, so as to obtain a dataset that yields batches of augmented images, like this: augmented_train_ds = train_ds.map( lambda x, y: (data_augmentation(x, training=True), y)) With this option, your data augmentation will happen on CPU, asynchronously, and will be buffered before going into the model. If you're training on CPU, this is the better option, since it makes data augmentation asynchronous and non-blocking. In our case, we'll go with the first option. Configure the dataset for performance Let's make sure to use buffered prefetching so we can yield data from disk without having I/O becoming blocking: train_ds = train_ds.prefetch(buffer_size=32) val_ds = val_ds.prefetch(buffer_size=32) Build a model We'll build a small version of the Xception network. We haven't particularly tried to optimize the architecture; if you want to do a systematic search for the best model configuration, consider using KerasTuner. Note that: We start the model with the data_augmentation preprocessor, followed by a Rescaling layer. We include a Dropout layer before the final classification layer. def make_model(input_shape, num_classes): inputs = keras.Input(shape=input_shape) # Image augmentation block x = data_augmentation(inputs) # Entry block x = layers.Rescaling(1.0 / 255)(x) x = layers.Conv2D(32, 3, strides=2, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) x = layers.Conv2D(64, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) previous_block_activation = x # Set aside residual for size in [128, 256, 512, 728]: x = layers.Activation(\"relu\")(x) x = layers.SeparableConv2D(size, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) x = layers.SeparableConv2D(size, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.MaxPooling2D(3, strides=2, padding=\"same\")(x) # Project residual residual = layers.Conv2D(size, 1, strides=2, padding=\"same\")( previous_block_activation ) x = layers.add([x, residual]) # Add back residual previous_block_activation = x # Set aside next residual x = layers.SeparableConv2D(1024, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) x = layers.GlobalAveragePooling2D()(x) if num_classes == 2: activation = \"sigmoid\" units = 1 else: activation = \"softmax\" units = num_classes x = layers.Dropout(0.5)(x) outputs = layers.Dense(units, activation=activation)(x) return keras.Model(inputs, outputs) model = make_model(input_shape=image_size + (3,), num_classes=2) keras.utils.plot_model(model, show_shapes=True) ('Failed to import pydot. You must `pip install pydot` and install graphviz (https://graphviz.gitlab.io/download/), ', 'for `pydotprint` to work.') Train the model epochs = 50 callbacks = [ keras.callbacks.ModelCheckpoint(\"save_at_{epoch}.h5\"), ] model.compile( optimizer=keras.optimizers.Adam(1e-3), loss=\"binary_crossentropy\", metrics=[\"accuracy\"], ) model.fit( train_ds, epochs=epochs, callbacks=callbacks, validation_data=val_ds, ) Epoch 1/50 586/586 [==============================] - 81s 139ms/step - loss: 0.6233 - accuracy: 0.6700 - val_loss: 0.7698 - val_accuracy: 0.6117 Epoch 2/50 586/586 [==============================] - 80s 137ms/step - loss: 0.4638 - accuracy: 0.7840 - val_loss: 0.4056 - val_accuracy: 0.8178 Epoch 3/50 586/586 [==============================] - 80s 137ms/step - loss: 0.3652 - accuracy: 0.8405 - val_loss: 0.3535 - val_accuracy: 0.8528 Epoch 4/50 586/586 [==============================] - 80s 137ms/step - loss: 0.3112 - accuracy: 0.8675 - val_loss: 0.2673 - val_accuracy: 0.8894 Epoch 5/50 586/586 [==============================] - 80s 137ms/step - loss: 0.2585 - accuracy: 0.8928 - val_loss: 0.6213 - val_accuracy: 0.7294 Epoch 6/50 586/586 [==============================] - 81s 138ms/step - loss: 0.2218 - accuracy: 0.9071 - val_loss: 0.2377 - val_accuracy: 0.8930 Epoch 7/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1992 - accuracy: 0.9169 - val_loss: 1.1273 - val_accuracy: 0.6254 Epoch 8/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1820 - accuracy: 0.9243 - val_loss: 0.1955 - val_accuracy: 0.9173 Epoch 9/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1694 - accuracy: 0.9308 - val_loss: 0.1602 - val_accuracy: 0.9314 Epoch 10/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1623 - accuracy: 0.9333 - val_loss: 0.1777 - val_accuracy: 0.9248 Epoch 11/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1522 - accuracy: 0.9365 - val_loss: 0.1562 - val_accuracy: 0.9400 Epoch 12/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1458 - accuracy: 0.9417 - val_loss: 0.1529 - val_accuracy: 0.9338 Epoch 13/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1368 - accuracy: 0.9433 - val_loss: 0.1694 - val_accuracy: 0.9259 Epoch 14/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1301 - accuracy: 0.9461 - val_loss: 0.1250 - val_accuracy: 0.9530 Epoch 15/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1261 - accuracy: 0.9483 - val_loss: 0.1548 - val_accuracy: 0.9353 Epoch 16/50 586/586 [==============================] - 81s 137ms/step - loss: 0.1241 - accuracy: 0.9497 - val_loss: 0.1376 - val_accuracy: 0.9464 Epoch 17/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1193 - accuracy: 0.9535 - val_loss: 0.1093 - val_accuracy: 0.9575 Epoch 18/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1107 - accuracy: 0.9558 - val_loss: 0.1488 - val_accuracy: 0.9432 Epoch 19/50 586/586 [==============================] - 80s 137ms/step - loss: 0.1175 - accuracy: 0.9532 - val_loss: 0.1380 - val_accuracy: 0.9421 Epoch 20/50 586/586 [==============================] - 81s 138ms/step - loss: 0.1026 - accuracy: 0.9584 - val_loss: 0.1293 - val_accuracy: 0.9485 Epoch 21/50 586/586 [==============================] - 80s 137ms/step - loss: 0.0977 - accuracy: 0.9606 - val_loss: 0.1105 - val_accuracy: 0.9573 Epoch 22/50 586/586 [==============================] - 80s 137ms/step - loss: 0.0983 - accuracy: 0.9610 - val_loss: 0.1023 - val_accuracy: 0.9633 Epoch 23/50 586/586 [==============================] - 80s 137ms/step - loss: 0.0776 - accuracy: 0.9694 - val_loss: 0.1176 - val_accuracy: 0.9530 Epoch 38/50 586/586 [==============================] - 80s 136ms/step - loss: 0.0596 - accuracy: 0.9768 - val_loss: 0.0967 - val_accuracy: 0.9633 Epoch 44/50 586/586 [==============================] - 80s 136ms/step - loss: 0.0504 - accuracy: 0.9792 - val_loss: 0.0984 - val_accuracy: 0.9663 Epoch 50/50 586/586 [==============================] - 80s 137ms/step - loss: 0.0486 - accuracy: 0.9817 - val_loss: 0.1157 - val_accuracy: 0.9609 We get to ~96% validation accuracy after training for 50 epochs on the full dataset. Run inference on new data Note that data augmentation and dropout are inactive at inference time. img = keras.preprocessing.image.load_img( \"PetImages/Cat/6779.jpg\", target_size=image_size ) img_array = keras.preprocessing.image.img_to_array(img) img_array = tf.expand_dims(img_array, 0) # Create batch axis predictions = model.predict(img_array) score = predictions[0] print( \"This image is %.2f percent cat and %.2f percent dog.\" % (100 * (1 - score), 100 * score) ) This image is 84.34 percent cat and 15.66 percent dog. BigTransfer (BiT) State-of-the-art transfer learning for image classification. Introduction BigTransfer (also known as BiT) is a state-of-the-art transfer learning method for image classification. Transfer of pre-trained representations improves sample efficiency and simplifies hyperparameter tuning when training deep neural networks for vision. BiT revisit the paradigm of pre-training on large supervised datasets and fine-tuning the model on a target task. The importance of appropriately choosing normalization layers and scaling the architecture capacity as the amount of pre-training data increases. BigTransfer(BiT) is trained on public datasets, along with code in TF2, Jax and Pytorch. This will help anyone to reach state of the art performance on their task of interest, even with just a handful of labeled images per class. You can find BiT models pre-trained on ImageNet and ImageNet-21k in TFHub as TensorFlow2 SavedModels that you can use easily as Keras Layers. There are a variety of sizes ranging from a standard ResNet50 to a ResNet152x4 (152 layers deep, 4x wider than a typical ResNet50) for users with larger computational and memory budgets but higher accuracy requirements. Figure: The x-axis shows the number of images used per class, ranging from 1 to the full dataset. On the plots on the left, the curve in blue above is our BiT-L model, whereas the curve below is a ResNet-50 pre-trained on ImageNet (ILSVRC-2012). Setup import numpy as np import pandas as pd import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras import tensorflow_hub as hub import tensorflow_datasets as tfds tfds.disable_progress_bar() SEEDS = 42 np.random.seed(SEEDS) tf.random.set_seed(SEEDS) Gather Flower Dataset train_ds, validation_ds = tfds.load( \"tf_flowers\", split=[\"train[:85%]\", \"train[85%:]\"], as_supervised=True, ) Downloading and preparing dataset tf_flowers/3.0.1 (download: 218.21 MiB, generated: 221.83 MiB, total: 440.05 MiB) to /root/tensorflow_datasets/tf_flowers/3.0.1... Dataset tf_flowers downloaded and prepared to /root/tensorflow_datasets/tf_flowers/3.0.1. Subsequent calls will reuse this data. Visualise the dataset plt.figure(figsize=(10, 10)) for i, (image, label) in enumerate(train_ds.take(9)): ax = plt.subplot(3, 3, i + 1) plt.imshow(image) plt.title(int(label)) plt.axis(\"off\") png Define hyperparameters RESIZE_TO = 384 CROP_TO = 224 BATCH_SIZE = 64 STEPS_PER_EPOCH = 10 AUTO = tf.data.AUTOTUNE # optimise the pipeline performance NUM_CLASSES = 5 # number of classes SCHEDULE_LENGTH = ( 500 # we will train on lower resolution images and will still attain good results ) SCHEDULE_BOUNDARIES = [ 200, 300, 400, ] # more the dataset size the schedule length increase The hyperparamteres like SCHEDULE_LENGTH and SCHEDULE_BOUNDARIES are determined based on empirical results. The method has been explained in the original paper and in their Google AI Blog Post. The SCHEDULE_LENGTH is aslo determined whether to use MixUp Augmentation or not. You can also find an easy MixUp Implementation in Keras Coding Examples. Define preprocessing helper functions SCHEDULE_LENGTH = SCHEDULE_LENGTH * 512 / BATCH_SIZE @tf.function def preprocess_train(image, label): image = tf.image.random_flip_left_right(image) image = tf.image.resize(image, (RESIZE_TO, RESIZE_TO)) image = tf.image.random_crop(image, (CROP_TO, CROP_TO, 3)) image = image / 255.0 return (image, label) @tf.function def preprocess_test(image, label): image = tf.image.resize(image, (RESIZE_TO, RESIZE_TO)) image = image / 255.0 return (image, label) DATASET_NUM_TRAIN_EXAMPLES = train_ds.cardinality().numpy() repeat_count = int( SCHEDULE_LENGTH * BATCH_SIZE / DATASET_NUM_TRAIN_EXAMPLES * STEPS_PER_EPOCH ) repeat_count += 50 + 1 # To ensure at least there are 50 epochs of training Define the data pipeline # Training pipeline pipeline_train = ( train_ds.shuffle(10000) .repeat(repeat_count) # Repeat dataset_size / num_steps .map(preprocess_train, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) # Validation pipeline pipeline_validation = ( validation_ds.map(preprocess_test, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) Visualise the training samples image_batch, label_batch = next(iter(pipeline_train)) plt.figure(figsize=(10, 10)) for n in range(25): ax = plt.subplot(5, 5, n + 1) plt.imshow(image_batch[n]) plt.title(label_batch[n].numpy()) plt.axis(\"off\") png Load pretrained TF-Hub model into a KerasLayer bit_model_url = \"https://tfhub.dev/google/bit/m-r50x1/1\" bit_module = hub.KerasLayer(bit_model_url) Create BigTransfer (BiT) model To create the new model, we: Cut off the BiT model’s original head. This leaves us with the “pre-logits” output. We do not have to do this if we use the ‘feature extractor’ models (i.e. all those in subdirectories titled feature_vectors), since for those models the head has already been cut off. Add a new head with the number of outputs equal to the number of classes of our new task. Note that it is important that we initialise the head to all zeroes. class MyBiTModel(keras.Model): def __init__(self, num_classes, module, **kwargs): super().__init__(**kwargs) self.num_classes = num_classes self.head = keras.layers.Dense(num_classes, kernel_initializer=\"zeros\") self.bit_model = module def call(self, images): bit_embedding = self.bit_model(images) return self.head(bit_embedding) model = MyBiTModel(num_classes=NUM_CLASSES, module=bit_module) Define optimizer and loss learning_rate = 0.003 * BATCH_SIZE / 512 # Decay learning rate by a factor of 10 at SCHEDULE_BOUNDARIES. lr_schedule = keras.optimizers.schedules.PiecewiseConstantDecay( boundaries=SCHEDULE_BOUNDARIES, values=[ learning_rate, learning_rate * 0.1, learning_rate * 0.01, learning_rate * 0.001, ], ) optimizer = keras.optimizers.SGD(learning_rate=lr_schedule, momentum=0.9) loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True) Compile the model model.compile(optimizer=optimizer, loss=loss_fn, metrics=[\"accuracy\"]) Set up callbacks train_callbacks = [ keras.callbacks.EarlyStopping( monitor=\"val_accuracy\", patience=2, restore_best_weights=True ) ] Train the model history = model.fit( pipeline_train, batch_size=BATCH_SIZE, epochs=int(SCHEDULE_LENGTH / STEPS_PER_EPOCH), steps_per_epoch=STEPS_PER_EPOCH, validation_data=pipeline_validation, callbacks=train_callbacks, ) Epoch 1/400 10/10 [==============================] - 41s 1s/step - loss: 0.7440 - accuracy: 0.7844 - val_loss: 0.1837 - val_accuracy: 0.9582 Epoch 2/400 10/10 [==============================] - 8s 904ms/step - loss: 0.1499 - accuracy: 0.9547 - val_loss: 0.1094 - val_accuracy: 0.9709 Epoch 3/400 10/10 [==============================] - 8s 905ms/step - loss: 0.1674 - accuracy: 0.9422 - val_loss: 0.0874 - val_accuracy: 0.9727 Epoch 4/400 10/10 [==============================] - 8s 905ms/step - loss: 0.1314 - accuracy: 0.9578 - val_loss: 0.0829 - val_accuracy: 0.9727 Epoch 5/400 10/10 [==============================] - 8s 903ms/step - loss: 0.1336 - accuracy: 0.9500 - val_loss: 0.0765 - val_accuracy: 0.9727 Plot the training and validation metrics def plot_hist(hist): plt.plot(hist.history[\"accuracy\"]) plt.plot(hist.history[\"val_accuracy\"]) plt.plot(hist.history[\"loss\"]) plt.plot(hist.history[\"val_loss\"]) plt.title(\"Training Progress\") plt.ylabel(\"Accuracy/Loss\") plt.xlabel(\"Epochs\") plt.legend([\"train_acc\", \"val_acc\", \"train_loss\", \"val_loss\"], loc=\"upper left\") plt.show() plot_hist(history) png Evaluate the model accuracy = model.evaluate(pipeline_validation)[1] * 100 print(\"Accuracy: {:.2f}%\".format(accuracy)) 9/9 [==============================] - 6s 646ms/step - loss: 0.0874 - accuracy: 0.9727 Accuracy: 97.27% Conclusion BiT performs well across a surprisingly wide range of data regimes -- from 1 example per class to 1M total examples. BiT achieves 87.5% top-1 accuracy on ILSVRC-2012, 99.4% on CIFAR-10, and 76.3% on the 19 task Visual Task Adaptation Benchmark (VTAB). On small datasets, BiT attains 76.8% on ILSVRC-2012 with 10 examples per class, and 97.0% on CIFAR-10 with 10 examples per class. You can experiment further with the BigTransfer Method by following the original paper. Use EfficientNet with weights pre-trained on imagenet for Stanford Dogs classification. Introduction: what is EfficientNet EfficientNet, first introduced in Tan and Le, 2019 is among the most efficient models (i.e. requiring least FLOPS for inference) that reaches State-of-the-Art accuracy on both imagenet and common image classification transfer learning tasks. The smallest base model is similar to MnasNet, which reached near-SOTA with a significantly smaller model. By introducing a heuristic way to scale the model, EfficientNet provides a family of models (B0 to B7) that represents a good combination of efficiency and accuracy on a variety of scales. Such a scaling heuristics (compound-scaling, details see Tan and Le, 2019) allows the efficiency-oriented base model (B0) to surpass models at every scale, while avoiding extensive grid-search of hyperparameters. A summary of the latest updates on the model is available at here, where various augmentation schemes and semi-supervised learning approaches are applied to further improve the imagenet performance of the models. These extensions of the model can be used by updating weights without changing model architecture. B0 to B7 variants of EfficientNet (This section provides some details on \"compound scaling\", and can be skipped if you're only interested in using the models) Based on the original paper people may have the impression that EfficientNet is a continuous family of models created by arbitrarily choosing scaling factor in as Eq.(3) of the paper. However, choice of resolution, depth and width are also restricted by many factors: Resolution: Resolutions not divisible by 8, 16, etc. cause zero-padding near boundaries of some layers which wastes computational resources. This especially applies to smaller variants of the model, hence the input resolution for B0 and B1 are chosen as 224 and 240. Depth and width: The building blocks of EfficientNet demands channel size to be multiples of 8. Resource limit: Memory limitation may bottleneck resolution when depth and width can still increase. In such a situation, increasing depth and/or width but keep resolution can still improve performance. As a result, the depth, width and resolution of each variant of the EfficientNet models are hand-picked and proven to produce good results, though they may be significantly off from the compound scaling formula. Therefore, the keras implementation (detailed below) only provide these 8 models, B0 to B7, instead of allowing arbitray choice of width / depth / resolution parameters. Keras implementation of EfficientNet An implementation of EfficientNet B0 to B7 has been shipped with tf.keras since TF2.3. To use EfficientNetB0 for classifying 1000 classes of images from imagenet, run: from tensorflow.keras.applications import EfficientNetB0 model = EfficientNetB0(weights='imagenet') This model takes input images of shape (224, 224, 3), and the input data should range [0, 255]. Normalization is included as part of the model. Because training EfficientNet on ImageNet takes a tremendous amount of resources and several techniques that are not a part of the model architecture itself. Hence the Keras implementation by default loads pre-trained weights obtained via training with AutoAugment. For B0 to B7 base models, the input shapes are different. Here is a list of input shape expected for each model: Base model resolution EfficientNetB0 224 EfficientNetB1 240 EfficientNetB2 260 EfficientNetB3 300 EfficientNetB4 380 EfficientNetB5 456 EfficientNetB6 528 EfficientNetB7 600 When the model is intended for transfer learning, the Keras implementation provides a option to remove the top layers: model = EfficientNetB0(include_top=False, weights='imagenet') This option excludes the final Dense layer that turns 1280 features on the penultimate layer into prediction of the 1000 ImageNet classes. Replacing the top layer with custom layers allows using EfficientNet as a feature extractor in a transfer learning workflow. Another argument in the model constructor worth noticing is drop_connect_rate which controls the dropout rate responsible for stochastic depth. This parameter serves as a toggle for extra regularization in finetuning, but does not affect loaded weights. For example, when stronger regularization is desired, try: model = EfficientNetB0(weights='imagenet', drop_connect_rate=0.4) The default value is 0.2. Example: EfficientNetB0 for Stanford Dogs. EfficientNet is capable of a wide range of image classification tasks. This makes it a good model for transfer learning. As an end-to-end example, we will show using pre-trained EfficientNetB0 on Stanford Dogs dataset. # IMG_SIZE is determined by EfficientNet model choice IMG_SIZE = 224 Setup and data loading This example requires TensorFlow 2.3 or above. To use TPU, the TPU runtime must match current running TensorFlow version. If there is a mismatch, try: from cloud_tpu_client import Client c = Client() c.configure_tpu_version(tf.__version__, restart_type=\"always\") import tensorflow as tf try: tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect() print(\"Device:\", tpu.master()) strategy = tf.distribute.TPUStrategy(tpu) except ValueError: print(\"Not connected to a TPU runtime. Using CPU/GPU strategy\") strategy = tf.distribute.MirroredStrategy() Not connected to a TPU runtime. Using CPU/GPU strategy INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',) Loading data Here we load data from tensorflow_datasets (hereafter TFDS). Stanford Dogs dataset is provided in TFDS as stanford_dogs. It features 20,580 images that belong to 120 classes of dog breeds (12,000 for training and 8,580 for testing). By simply changing dataset_name below, you may also try this notebook for other datasets in TFDS such as cifar10, cifar100, food101, etc. When the images are much smaller than the size of EfficientNet input, we can simply upsample the input images. It has been shown in Tan and Le, 2019 that transfer learning result is better for increased resolution even if input images remain small. For TPU: if using TFDS datasets, a GCS bucket location is required to save the datasets. For example: tfds.load(dataset_name, data_dir=\"gs://example-bucket/datapath\") Also, both the current environment and the TPU service account have proper access to the bucket. Alternatively, for small datasets you may try loading data into the memory and use tf.data.Dataset.from_tensor_slices(). import tensorflow_datasets as tfds batch_size = 64 dataset_name = \"stanford_dogs\" (ds_train, ds_test), ds_info = tfds.load( dataset_name, split=[\"train\", \"test\"], with_info=True, as_supervised=True ) NUM_CLASSES = ds_info.features[\"label\"].num_classes When the dataset include images with various size, we need to resize them into a shared size. The Stanford Dogs dataset includes only images at least 200x200 pixels in size. Here we resize the images to the input size needed for EfficientNet. size = (IMG_SIZE, IMG_SIZE) ds_train = ds_train.map(lambda image, label: (tf.image.resize(image, size), label)) ds_test = ds_test.map(lambda image, label: (tf.image.resize(image, size), label)) Visualizing the data The following code shows the first 9 images with their labels. import matplotlib.pyplot as plt def format_label(label): string_label = label_info.int2str(label) return string_label.split(\"-\")[1] label_info = ds_info.features[\"label\"] for i, (image, label) in enumerate(ds_train.take(9)): ax = plt.subplot(3, 3, i + 1) plt.imshow(image.numpy().astype(\"uint8\")) plt.title(\"{}\".format(format_label(label))) plt.axis(\"off\") png Data augmentation We can use the preprocessing layers APIs for image augmentation. from tensorflow.keras.models import Sequential from tensorflow.keras import layers img_augmentation = Sequential( [ layers.RandomRotation(factor=0.15), layers.RandomTranslation(height_factor=0.1, width_factor=0.1), layers.RandomFlip(), layers.RandomContrast(factor=0.1), ], name=\"img_augmentation\", ) This Sequential model object can be used both as a part of the model we later build, and as a function to preprocess data before feeding into the model. Using them as function makes it easy to visualize the augmented images. Here we plot 9 examples of augmentation result of a given figure. for image, label in ds_train.take(1): for i in range(9): ax = plt.subplot(3, 3, i + 1) aug_img = img_augmentation(tf.expand_dims(image, axis=0)) plt.imshow(aug_img[0].numpy().astype(\"uint8\")) plt.title(\"{}\".format(format_label(label))) plt.axis(\"off\") png Prepare inputs Once we verify the input data and augmentation are working correctly, we prepare dataset for training. The input data are resized to uniform IMG_SIZE. The labels are put into one-hot (a.k.a. categorical) encoding. The dataset is batched. Note: prefetch and AUTOTUNE may in some situation improve performance, but depends on environment and the specific dataset used. See this guide for more information on data pipeline performance. # One-hot / categorical encoding def input_preprocess(image, label): label = tf.one_hot(label, NUM_CLASSES) return image, label ds_train = ds_train.map( input_preprocess, num_parallel_calls=tf.data.AUTOTUNE ) ds_train = ds_train.batch(batch_size=batch_size, drop_remainder=True) ds_train = ds_train.prefetch(tf.data.AUTOTUNE) ds_test = ds_test.map(input_preprocess) ds_test = ds_test.batch(batch_size=batch_size, drop_remainder=True) Training a model from scratch We build an EfficientNetB0 with 120 output classes, that is initialized from scratch: Note: the accuracy will increase very slowly and may overfit. from tensorflow.keras.applications import EfficientNetB0 with strategy.scope(): inputs = layers.Input(shape=(IMG_SIZE, IMG_SIZE, 3)) x = img_augmentation(inputs) outputs = EfficientNetB0(include_top=True, weights=None, classes=NUM_CLASSES)(x) model = tf.keras.Model(inputs, outputs) model.compile( optimizer=\"adam\", loss=\"categorical_crossentropy\", metrics=[\"accuracy\"] ) model.summary() epochs = 40 # @param {type: \"slider\", min:10, max:100} hist = model.fit(ds_train, epochs=epochs, validation_data=ds_test, verbose=2) Model: \"functional_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 224, 224, 3)] 0 _________________________________________________________________ img_augmentation (Sequential (None, 224, 224, 3) 0 _________________________________________________________________ efficientnetb0 (Functional) (None, 120) 4203291 ================================================================= Total params: 4,203,291 Trainable params: 4,161,268 Non-trainable params: 42,023 _________________________________________________________________ Epoch 1/40 187/187 - 66s - loss: 4.9221 - accuracy: 0.0119 - val_loss: 4.9835 - val_accuracy: 0.0104 Epoch 2/40 187/187 - 63s - loss: 4.5652 - accuracy: 0.0243 - val_loss: 5.1626 - val_accuracy: 0.0145 Epoch 3/40 187/187 - 63s - loss: 4.4179 - accuracy: 0.0337 - val_loss: 4.7597 - val_accuracy: 0.0237 Epoch 4/40 187/187 - 63s - loss: 4.2964 - accuracy: 0.0421 - val_loss: 4.4028 - val_accuracy: 0.0378 Epoch 5/40 187/187 - 63s - loss: 4.1951 - accuracy: 0.0540 - val_loss: 4.3048 - val_accuracy: 0.0443 Epoch 6/40 187/187 - 63s - loss: 4.1025 - accuracy: 0.0596 - val_loss: 4.1918 - val_accuracy: 0.0526 Epoch 7/40 187/187 - 63s - loss: 4.0157 - accuracy: 0.0728 - val_loss: 4.1482 - val_accuracy: 0.0591 Epoch 8/40 187/187 - 62s - loss: 3.9344 - accuracy: 0.0844 - val_loss: 4.1088 - val_accuracy: 0.0638 Epoch 9/40 187/187 - 63s - loss: 3.8529 - accuracy: 0.0951 - val_loss: 4.0692 - val_accuracy: 0.0770 Epoch 10/40 187/187 - 63s - loss: 3.7650 - accuracy: 0.1040 - val_loss: 4.1468 - val_accuracy: 0.0719 Epoch 11/40 187/187 - 63s - loss: 3.6858 - accuracy: 0.1185 - val_loss: 4.0484 - val_accuracy: 0.0913 Epoch 12/40 187/187 - 63s - loss: 3.5942 - accuracy: 0.1326 - val_loss: 3.8047 - val_accuracy: 0.1072 Epoch 13/40 187/187 - 63s - loss: 3.5028 - accuracy: 0.1447 - val_loss: 3.9513 - val_accuracy: 0.0933 Epoch 14/40 187/187 - 63s - loss: 3.4295 - accuracy: 0.1604 - val_loss: 3.7738 - val_accuracy: 0.1220 Epoch 15/40 187/187 - 63s - loss: 3.3410 - accuracy: 0.1735 - val_loss: 3.9104 - val_accuracy: 0.1104 Epoch 16/40 187/187 - 63s - loss: 3.2511 - accuracy: 0.1890 - val_loss: 3.6904 - val_accuracy: 0.1264 Epoch 17/40 187/187 - 63s - loss: 3.1624 - accuracy: 0.2076 - val_loss: 3.4026 - val_accuracy: 0.1769 Epoch 18/40 187/187 - 63s - loss: 3.0825 - accuracy: 0.2229 - val_loss: 3.4627 - val_accuracy: 0.1744 Epoch 19/40 187/187 - 63s - loss: 3.0041 - accuracy: 0.2355 - val_loss: 3.6061 - val_accuracy: 0.1542 Epoch 20/40 187/187 - 64s - loss: 2.8945 - accuracy: 0.2552 - val_loss: 3.2769 - val_accuracy: 0.2036 Epoch 21/40 187/187 - 63s - loss: 2.8054 - accuracy: 0.2710 - val_loss: 3.5355 - val_accuracy: 0.1834 Epoch 22/40 187/187 - 63s - loss: 2.7342 - accuracy: 0.2904 - val_loss: 3.3540 - val_accuracy: 0.1973 Epoch 23/40 187/187 - 62s - loss: 2.6258 - accuracy: 0.3042 - val_loss: 3.2608 - val_accuracy: 0.2217 Epoch 24/40 187/187 - 62s - loss: 2.5453 - accuracy: 0.3218 - val_loss: 3.4611 - val_accuracy: 0.1941 Epoch 25/40 187/187 - 63s - loss: 2.4585 - accuracy: 0.3356 - val_loss: 3.4163 - val_accuracy: 0.2070 Epoch 26/40 187/187 - 62s - loss: 2.3606 - accuracy: 0.3647 - val_loss: 3.2558 - val_accuracy: 0.2392 Epoch 27/40 187/187 - 63s - loss: 2.2819 - accuracy: 0.3801 - val_loss: 3.3676 - val_accuracy: 0.2222 Epoch 28/40 187/187 - 62s - loss: 2.2114 - accuracy: 0.3933 - val_loss: 3.6578 - val_accuracy: 0.2022 Epoch 29/40 187/187 - 62s - loss: 2.0964 - accuracy: 0.4215 - val_loss: 3.5366 - val_accuracy: 0.2186 Epoch 30/40 187/187 - 63s - loss: 1.9931 - accuracy: 0.4459 - val_loss: 3.5612 - val_accuracy: 0.2310 Epoch 31/40 187/187 - 63s - loss: 1.8924 - accuracy: 0.4657 - val_loss: 3.4780 - val_accuracy: 0.2359 Epoch 32/40 187/187 - 63s - loss: 1.8095 - accuracy: 0.4874 - val_loss: 3.5776 - val_accuracy: 0.2403 Epoch 33/40 187/187 - 63s - loss: 1.7126 - accuracy: 0.5086 - val_loss: 3.6865 - val_accuracy: 0.2316 Epoch 34/40 187/187 - 63s - loss: 1.6117 - accuracy: 0.5373 - val_loss: 3.6419 - val_accuracy: 0.2513 Epoch 35/40 187/187 - 63s - loss: 1.5532 - accuracy: 0.5514 - val_loss: 3.8050 - val_accuracy: 0.2415 Epoch 36/40 187/187 - 63s - loss: 1.4479 - accuracy: 0.5809 - val_loss: 4.0113 - val_accuracy: 0.2299 Epoch 37/40 187/187 - 62s - loss: 1.3885 - accuracy: 0.5939 - val_loss: 4.1262 - val_accuracy: 0.2158 Epoch 38/40 187/187 - 63s - loss: 1.2979 - accuracy: 0.6217 - val_loss: 4.2519 - val_accuracy: 0.2344 Epoch 39/40 187/187 - 62s - loss: 1.2066 - accuracy: 0.6413 - val_loss: 4.3924 - val_accuracy: 0.2169 Epoch 40/40 187/187 - 62s - loss: 1.1348 - accuracy: 0.6618 - val_loss: 4.2216 - val_accuracy: 0.2374 Training the model is relatively fast (takes only 20 seconds per epoch on TPUv2 that is available on Colab). This might make it sounds easy to simply train EfficientNet on any dataset wanted from scratch. However, training EfficientNet on smaller datasets, especially those with lower resolution like CIFAR-100, faces the significant challenge of overfitting. Hence training from scratch requires very careful choice of hyperparameters and is difficult to find suitable regularization. It would also be much more demanding in resources. Plotting the training and validation accuracy makes it clear that validation accuracy stagnates at a low value. import matplotlib.pyplot as plt def plot_hist(hist): plt.plot(hist.history[\"accuracy\"]) plt.plot(hist.history[\"val_accuracy\"]) plt.title(\"model accuracy\") plt.ylabel(\"accuracy\") plt.xlabel(\"epoch\") plt.legend([\"train\", \"validation\"], loc=\"upper left\") plt.show() plot_hist(hist) png Transfer learning from pre-trained weights Here we initialize the model with pre-trained ImageNet weights, and we fine-tune it on our own dataset. def build_model(num_classes): inputs = layers.Input(shape=(IMG_SIZE, IMG_SIZE, 3)) x = img_augmentation(inputs) model = EfficientNetB0(include_top=False, input_tensor=x, weights=\"imagenet\") # Freeze the pretrained weights model.trainable = False # Rebuild top x = layers.GlobalAveragePooling2D(name=\"avg_pool\")(model.output) x = layers.BatchNormalization()(x) top_dropout_rate = 0.2 x = layers.Dropout(top_dropout_rate, name=\"top_dropout\")(x) outputs = layers.Dense(NUM_CLASSES, activation=\"softmax\", name=\"pred\")(x) # Compile model = tf.keras.Model(inputs, outputs, name=\"EfficientNet\") optimizer = tf.keras.optimizers.Adam(learning_rate=1e-2) model.compile( optimizer=optimizer, loss=\"categorical_crossentropy\", metrics=[\"accuracy\"] ) return model The first step to transfer learning is to freeze all layers and train only the top layers. For this step, a relatively large learning rate (1e-2) can be used. Note that validation accuracy and loss will usually be better than training accuracy and loss. This is because the regularization is strong, which only suppresses training-time metrics. Note that the convergence may take up to 50 epochs depending on choice of learning rate. If image augmentation layers were not applied, the validation accuracy may only reach ~60%. with strategy.scope(): model = build_model(num_classes=NUM_CLASSES) epochs = 25 # @param {type: \"slider\", min:8, max:80} hist = model.fit(ds_train, epochs=epochs, validation_data=ds_test, verbose=2) plot_hist(hist) Epoch 1/25 187/187 - 33s - loss: 3.5673 - accuracy: 0.3624 - val_loss: 1.0288 - val_accuracy: 0.6957 Epoch 2/25 187/187 - 31s - loss: 1.8503 - accuracy: 0.5232 - val_loss: 0.8439 - val_accuracy: 0.7484 Epoch 3/25 187/187 - 31s - loss: 1.5511 - accuracy: 0.5772 - val_loss: 0.7953 - val_accuracy: 0.7563 Epoch 4/25 187/187 - 31s - loss: 1.4660 - accuracy: 0.5878 - val_loss: 0.8061 - val_accuracy: 0.7535 Epoch 5/25 187/187 - 31s - loss: 1.4143 - accuracy: 0.6034 - val_loss: 0.7850 - val_accuracy: 0.7569 Epoch 6/25 187/187 - 31s - loss: 1.4000 - accuracy: 0.6054 - val_loss: 0.7846 - val_accuracy: 0.7646 Epoch 7/25 187/187 - 31s - loss: 1.3678 - accuracy: 0.6173 - val_loss: 0.7850 - val_accuracy: 0.7682 Epoch 8/25 187/187 - 31s - loss: 1.3286 - accuracy: 0.6222 - val_loss: 0.8142 - val_accuracy: 0.7608 Epoch 9/25 187/187 - 31s - loss: 1.3210 - accuracy: 0.6245 - val_loss: 0.7890 - val_accuracy: 0.7669 Epoch 10/25 187/187 - 31s - loss: 1.3086 - accuracy: 0.6278 - val_loss: 0.8368 - val_accuracy: 0.7575 Epoch 11/25 187/187 - 31s - loss: 1.2877 - accuracy: 0.6315 - val_loss: 0.8309 - val_accuracy: 0.7599 Epoch 12/25 187/187 - 31s - loss: 1.2918 - accuracy: 0.6308 - val_loss: 0.8319 - val_accuracy: 0.7535 Epoch 13/25 187/187 - 31s - loss: 1.2738 - accuracy: 0.6373 - val_loss: 0.8567 - val_accuracy: 0.7576 Epoch 14/25 187/187 - 31s - loss: 1.2837 - accuracy: 0.6410 - val_loss: 0.8004 - val_accuracy: 0.7697 Epoch 15/25 187/187 - 31s - loss: 1.2828 - accuracy: 0.6403 - val_loss: 0.8364 - val_accuracy: 0.7625 Epoch 16/25 187/187 - 31s - loss: 1.2749 - accuracy: 0.6405 - val_loss: 0.8558 - val_accuracy: 0.7565 Epoch 17/25 187/187 - 31s - loss: 1.3022 - accuracy: 0.6352 - val_loss: 0.8361 - val_accuracy: 0.7551 Epoch 18/25 187/187 - 31s - loss: 1.2848 - accuracy: 0.6394 - val_loss: 0.8958 - val_accuracy: 0.7479 Epoch 19/25 187/187 - 31s - loss: 1.2791 - accuracy: 0.6420 - val_loss: 0.8875 - val_accuracy: 0.7509 Epoch 20/25 187/187 - 30s - loss: 1.2834 - accuracy: 0.6416 - val_loss: 0.8653 - val_accuracy: 0.7607 Epoch 21/25 187/187 - 30s - loss: 1.2608 - accuracy: 0.6435 - val_loss: 0.8451 - val_accuracy: 0.7612 Epoch 22/25 187/187 - 30s - loss: 1.2780 - accuracy: 0.6390 - val_loss: 0.9035 - val_accuracy: 0.7486 Epoch 23/25 187/187 - 30s - loss: 1.2742 - accuracy: 0.6473 - val_loss: 0.8837 - val_accuracy: 0.7556 Epoch 24/25 187/187 - 30s - loss: 1.2609 - accuracy: 0.6434 - val_loss: 0.9233 - val_accuracy: 0.7524 Epoch 25/25 187/187 - 31s - loss: 1.2630 - accuracy: 0.6496 - val_loss: 0.9116 - val_accuracy: 0.7584 png The second step is to unfreeze a number of layers and fit the model using smaller learning rate. In this example we show unfreezing all layers, but depending on specific dataset it may be desireble to only unfreeze a fraction of all layers. When the feature extraction with pretrained model works good enough, this step would give a very limited gain on validation accuracy. In our case we only see a small improvement, as ImageNet pretraining already exposed the model to a good amount of dogs. On the other hand, when we use pretrained weights on a dataset that is more different from ImageNet, this fine-tuning step can be crucial as the feature extractor also needs to be adjusted by a considerable amount. Such a situation can be demonstrated if choosing CIFAR-100 dataset instead, where fine-tuning boosts validation accuracy by about 10% to pass 80% on EfficientNetB0. In such a case the convergence may take more than 50 epochs. A side note on freezing/unfreezing models: setting trainable of a Model will simultaneously set all layers belonging to the Model to the same trainable attribute. Each layer is trainable only if both the layer itself and the model containing it are trainable. Hence when we need to partially freeze/unfreeze a model, we need to make sure the trainable attribute of the model is set to True. def unfreeze_model(model): # We unfreeze the top 20 layers while leaving BatchNorm layers frozen for layer in model.layers[-20:]: if not isinstance(layer, layers.BatchNormalization): layer.trainable = True optimizer = tf.keras.optimizers.Adam(learning_rate=1e-4) model.compile( optimizer=optimizer, loss=\"categorical_crossentropy\", metrics=[\"accuracy\"] ) unfreeze_model(model) epochs = 10 # @param {type: \"slider\", min:8, max:50} hist = model.fit(ds_train, epochs=epochs, validation_data=ds_test, verbose=2) plot_hist(hist) Epoch 1/10 187/187 - 33s - loss: 0.9956 - accuracy: 0.7080 - val_loss: 0.7644 - val_accuracy: 0.7856 Epoch 2/10 187/187 - 31s - loss: 0.8885 - accuracy: 0.7352 - val_loss: 0.7696 - val_accuracy: 0.7866 Epoch 3/10 187/187 - 31s - loss: 0.8059 - accuracy: 0.7533 - val_loss: 0.7659 - val_accuracy: 0.7885 Epoch 4/10 187/187 - 32s - loss: 0.7648 - accuracy: 0.7675 - val_loss: 0.7730 - val_accuracy: 0.7866 Epoch 5/10 187/187 - 32s - loss: 0.6982 - accuracy: 0.7833 - val_loss: 0.7691 - val_accuracy: 0.7858 Epoch 6/10 187/187 - 31s - loss: 0.6823 - accuracy: 0.7880 - val_loss: 0.7814 - val_accuracy: 0.7872 Epoch 7/10 187/187 - 31s - loss: 0.6536 - accuracy: 0.7953 - val_loss: 0.7850 - val_accuracy: 0.7873 Epoch 8/10 187/187 - 31s - loss: 0.6104 - accuracy: 0.8111 - val_loss: 0.7774 - val_accuracy: 0.7879 Epoch 9/10 187/187 - 32s - loss: 0.5990 - accuracy: 0.8067 - val_loss: 0.7925 - val_accuracy: 0.7870 Epoch 10/10 187/187 - 31s - loss: 0.5531 - accuracy: 0.8239 - val_loss: 0.7870 - val_accuracy: 0.7836 png Tips for fine tuning EfficientNet On unfreezing layers: The BathcNormalization layers need to be kept frozen (more details). If they are also turned to trainable, the first epoch after unfreezing will significantly reduce accuracy. In some cases it may be beneficial to open up only a portion of layers instead of unfreezing all. This will make fine tuning much faster when going to larger models like B7. Each block needs to be all turned on or off. This is because the architecture includes a shortcut from the first layer to the last layer for each block. Not respecting blocks also significantly harms the final performance. Some other tips for utilizing EfficientNet: Larger variants of EfficientNet do not guarantee improved performance, especially for tasks with less data or fewer classes. In such a case, the larger variant of EfficientNet chosen, the harder it is to tune hyperparameters. EMA (Exponential Moving Average) is very helpful in training EfficientNet from scratch, but not so much for transfer learning. Do not use the RMSprop setup as in the original paper for transfer learning. The momentum and learning rate are too high for transfer learning. It will easily corrupt the pretrained weight and blow up the loss. A quick check is to see if loss (as categorical cross entropy) is getting significantly larger than log(NUM_CLASSES) after the same epoch. If so, the initial learning rate/momentum is too high. Smaller batch size benefit validation accuracy, possibly due to effectively providing regularization. Using the latest EfficientNet weights Since the initial paper, the EfficientNet has been improved by various methods for data preprocessing and for using unlabelled data to enhance learning results. These improvements are relatively hard and computationally costly to reproduce, and require extra code; but the weights are readily available in the form of TF checkpoint files. The model architecture has not changed, so loading the improved checkpoints is possible. To use a checkpoint provided at the official model repository, first download the checkpoint. As example, here we download noisy-student version of B1: !wget https://storage.googleapis.com/cloud-tpu-checkpoints/efficientnet\ /noisystudent/noisy_student_efficientnet-b1.tar.gz !tar -xf noisy_student_efficientnet-b1.tar.gz Then use the script efficientnet_weight_update_util.py to convert ckpt file to h5 file. !python efficientnet_weight_update_util.py --model b1 --notop --ckpt \ efficientnet-b1/model.ckpt --o efficientnetb1_notop.h5 When creating model, use the following to load new weight: model = EfficientNetB1(weights=\"efficientnetb1_notop.h5\", include_top=False) An all-convolutional network applied to patches of images. Introduction Vision Transformers (ViT; Dosovitskiy et al.) extract small patches from the input images, linearly project them, and then apply the Transformer (Vaswani et al.) blocks. The application of ViTs to image recognition tasks is quickly becoming a promising area of research, because ViTs eliminate the need to have strong inductive biases (such as convolutions) for modeling locality. This presents them as a general computation primititive capable of learning just from the training data with as minimal inductive priors as possible. ViTs yield great downstream performance when trained with proper regularization, data augmentation, and relatively large datasets. In the Patches Are All You Need paper (note: at the time of writing, it is a submission to the ICLR 2022 conference), the authors extend the idea of using patches to train an all-convolutional network and demonstrate competitive results. Their architecture namely ConvMixer uses recipes from the recent isotrophic architectures like ViT, MLP-Mixer (Tolstikhin et al.), such as using the same depth and resolution across different layers in the network, residual connections, and so on. In this example, we will implement the ConvMixer model and demonstrate its performance on the CIFAR-10 dataset. To use the AdamW optimizer, we need to install TensorFlow Addons: pip install -U -q tensorflow-addons Imports from tensorflow.keras import layers from tensorflow import keras import matplotlib.pyplot as plt import tensorflow_addons as tfa import tensorflow as tf import numpy as np Hyperparameters To keep run time short, we will train the model for only 10 epochs. To focus on the core ideas of ConvMixer, we will not use other training-specific elements like RandAugment (Cubuk et al.). If you are interested in learning more about those details, please refer to the original paper. learning_rate = 0.001 weight_decay = 0.0001 batch_size = 128 num_epochs = 10 Load the CIFAR-10 dataset (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() val_split = 0.1 val_indices = int(len(x_train) * val_split) new_x_train, new_y_train = x_train[val_indices:], y_train[val_indices:] x_val, y_val = x_train[:val_indices], y_train[:val_indices] print(f\"Training data samples: {len(new_x_train)}\") print(f\"Validation data samples: {len(x_val)}\") print(f\"Test data samples: {len(x_test)}\") Training data samples: 45000 Validation data samples: 5000 Test data samples: 10000 Prepare tf.data.Dataset objects Our data augmentation pipeline is different from what the authors used for the CIFAR-10 dataset, which is fine for the purpose of the example. image_size = 32 auto = tf.data.AUTOTUNE data_augmentation = keras.Sequential( [layers.RandomCrop(image_size, image_size), layers.RandomFlip(\"horizontal\"),], name=\"data_augmentation\", ) def make_datasets(images, labels, is_train=False): dataset = tf.data.Dataset.from_tensor_slices((images, labels)) if is_train: dataset = dataset.shuffle(batch_size * 10) dataset = dataset.batch(batch_size) if is_train: dataset = dataset.map( lambda x, y: (data_augmentation(x), y), num_parallel_calls=auto ) return dataset.prefetch(auto) train_dataset = make_datasets(new_x_train, new_y_train, is_train=True) val_dataset = make_datasets(x_val, y_val) test_dataset = make_datasets(x_test, y_test) 2021-10-17 03:43:59.588315: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:43:59.596532: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:43:59.597211: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:43:59.622016: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. 2021-10-17 03:43:59.622853: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:43:59.623542: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:43:59.624174: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:44:00.067659: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:44:00.068334: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:44:00.068970: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-10-17 03:44:00.069615: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14684 MB memory: -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:04.0, compute capability: 7.0 ConvMixer utilities The following figure (taken from the original paper) depicts the ConvMixer model: ConvMixer is very similar to the MLP-Mixer, model with the following key differences: Instead of using fully-connected layers, it uses standard convolution layers. Instead of LayerNorm (which is typical for ViTs and MLP-Mixers), it uses BatchNorm. Two types of convolution layers are used in ConvMixer. (1): Depthwise convolutions, for mixing spatial locations of the images, (2): Pointwise convolutions (which follow the depthwise convolutions), for mixing channel-wise information across the patches. Another keypoint is the use of larger kernel sizes to allow a larger receptive field. def activation_block(x): x = layers.Activation(\"gelu\")(x) return layers.BatchNormalization()(x) def conv_stem(x, filters: int, patch_size: int): x = layers.Conv2D(filters, kernel_size=patch_size, strides=patch_size)(x) return activation_block(x) def conv_mixer_block(x, filters: int, kernel_size: int): # Depthwise convolution. x0 = x x = layers.DepthwiseConv2D(kernel_size=kernel_size, padding=\"same\")(x) x = layers.Add()([activation_block(x), x0]) # Residual. # Pointwise convolution. x = layers.Conv2D(filters, kernel_size=1)(x) x = activation_block(x) return x def get_conv_mixer_256_8( image_size=32, filters=256, depth=8, kernel_size=5, patch_size=2, num_classes=10 ): \"\"\"ConvMixer-256/8: https://openreview.net/pdf?id=TVHS5Y4dNvM. The hyperparameter values are taken from the paper. \"\"\" inputs = keras.Input((image_size, image_size, 3)) x = layers.Rescaling(scale=1.0 / 255)(inputs) # Extract patch embeddings. x = conv_stem(x, filters, patch_size) # ConvMixer blocks. for _ in range(depth): x = conv_mixer_block(x, filters, kernel_size) # Classification block. x = layers.GlobalAvgPool2D()(x) outputs = layers.Dense(num_classes, activation=\"softmax\")(x) return keras.Model(inputs, outputs) The model used in this experiment is termed as ConvMixer-256/8 where 256 denotes the number of channels and 8 denotes the depth. The resulting model only has 0.8 million parameters. Model training and evaluation utility # Code reference: # https://keras.io/examples/vision/image_classification_with_vision_transformer/. def run_experiment(model): optimizer = tfa.optimizers.AdamW( learning_rate=learning_rate, weight_decay=weight_decay ) model.compile( optimizer=optimizer, loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"], ) checkpoint_filepath = \"/tmp/checkpoint\" checkpoint_callback = keras.callbacks.ModelCheckpoint( checkpoint_filepath, monitor=\"val_accuracy\", save_best_only=True, save_weights_only=True, ) history = model.fit( train_dataset, validation_data=val_dataset, epochs=num_epochs, callbacks=[checkpoint_callback], ) model.load_weights(checkpoint_filepath) _, accuracy = model.evaluate(test_dataset) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") return history, model Train and evaluate model conv_mixer_model = get_conv_mixer_256_8() history, conv_mixer_model = run_experiment(conv_mixer_model) 2021-10-17 03:44:01.291445: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2) Epoch 1/10 2021-10-17 03:44:04.721186: I tensorflow/stream_executor/cuda/cuda_dnn.cc:369] Loaded cuDNN version 8005 352/352 [==============================] - 29s 70ms/step - loss: 1.2272 - accuracy: 0.5592 - val_loss: 3.9422 - val_accuracy: 0.1196 Epoch 2/10 352/352 [==============================] - 24s 69ms/step - loss: 0.7813 - accuracy: 0.7278 - val_loss: 0.8860 - val_accuracy: 0.6898 Epoch 3/10 352/352 [==============================] - 24s 68ms/step - loss: 0.5947 - accuracy: 0.7943 - val_loss: 0.6175 - val_accuracy: 0.7856 Epoch 4/10 352/352 [==============================] - 24s 69ms/step - loss: 0.4801 - accuracy: 0.8330 - val_loss: 0.5634 - val_accuracy: 0.8064 Epoch 5/10 352/352 [==============================] - 24s 68ms/step - loss: 0.4065 - accuracy: 0.8599 - val_loss: 0.5359 - val_accuracy: 0.8166 Epoch 6/10 352/352 [==============================] - 24s 68ms/step - loss: 0.3473 - accuracy: 0.8804 - val_loss: 0.5257 - val_accuracy: 0.8228 Epoch 7/10 352/352 [==============================] - 24s 68ms/step - loss: 0.3071 - accuracy: 0.8944 - val_loss: 0.4982 - val_accuracy: 0.8264 Epoch 8/10 352/352 [==============================] - 24s 68ms/step - loss: 0.2655 - accuracy: 0.9083 - val_loss: 0.5032 - val_accuracy: 0.8346 Epoch 9/10 352/352 [==============================] - 24s 68ms/step - loss: 0.2328 - accuracy: 0.9194 - val_loss: 0.5225 - val_accuracy: 0.8326 Epoch 10/10 352/352 [==============================] - 24s 68ms/step - loss: 0.2115 - accuracy: 0.9278 - val_loss: 0.5063 - val_accuracy: 0.8372 79/79 [==============================] - 2s 19ms/step - loss: 0.5412 - accuracy: 0.8325 Test accuracy: 83.25% The gap in training and validation performance can be mitigated by using additional regularization techniques. Nevertheless, being able to get to ~83% accuracy within 10 epochs with 0.8 million parameters is a strong result. Visualizing the internals of ConvMixer We can visualize the patch embeddings and the learned convolution filters. Recall that each patch embedding and intermediate feature map have the same number of channels (256 in this case). This will make our visualization utility easier to implement. # Code reference: https://bit.ly/3awIRbP. def visualization_plot(weights, idx=1): # First, apply min-max normalization to the # given weights to avoid isotrophic scaling. p_min, p_max = weights.min(), weights.max() weights = (weights - p_min) / (p_max - p_min) # Visualize all the filters. num_filters = 256 plt.figure(figsize=(8, 8)) for i in range(num_filters): current_weight = weights[:, :, :, i] if current_weight.shape[-1] == 1: current_weight = current_weight.squeeze() ax = plt.subplot(16, 16, idx) ax.set_xticks([]) ax.set_yticks([]) plt.imshow(current_weight) idx += 1 # We first visualize the learned patch embeddings. patch_embeddings = conv_mixer_model.layers[2].get_weights()[0] visualization_plot(patch_embeddings) png Even though we did not train the network to convergence, we can notice that different patches show different patterns. Some share similarity with others while some are very different. These visualizations are more salient with larger image sizes. Similarly, we can visualize the raw convolution kernels. This can help us understand the patterns to which a given kernel is receptive. # First, print the indices of the convolution layers that are not # pointwise convolutions. for i, layer in enumerate(conv_mixer_model.layers): if isinstance(layer, layers.DepthwiseConv2D): if layer.get_config()[\"kernel_size\"] == (5, 5): print(i, layer) idx = 26 # Taking a kernel from the middle of the network. kernel = conv_mixer_model.layers[idx].get_weights()[0] kernel = np.expand_dims(kernel.squeeze(), axis=2) visualization_plot(kernel) 5 12 19 26 33 40 47 54 png We see that different filters in the kernel have different locality spans, and this pattern is likely to evolve with more training. Final notes There's been a recent trend on fusing convolutions with other data-agnostic operations like self-attention. Following works are along this line of research: ConViT (d'Ascoli et al.) CCT (Hassani et al.) CoAtNet (Dai et al.) Image classification with a Transformer that leverages external attention. Introduction This example implements the EANet model for image classification, and demonstrates it on the CIFAR-100 dataset. EANet introduces a novel attention mechanism named external attention, based on two external, small, learnable, and shared memories, which can be implemented easily by simply using two cascaded linear layers and two normalization layers. It conveniently replaces self-attention as used in existing architectures. External attention has linear complexity, as it only implicitly considers the correlations between all samples. This example requires TensorFlow 2.5 or higher, as well as TensorFlow Addons package, which can be installed using the following command: pip install -U tensorflow-addons Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_addons as tfa import matplotlib.pyplot as plt Prepare the data num_classes = 100 input_shape = (32, 32, 3) (x_train, y_train), (x_test, y_test) = keras.datasets.cifar100.load_data() y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\") print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\") x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 100) x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 100) Configure the hyperparameters weight_decay = 0.0001 learning_rate = 0.001 label_smoothing = 0.1 validation_split = 0.2 batch_size = 128 num_epochs = 50 patch_size = 2 # Size of the patches to be extracted from the input images. num_patches = (input_shape[0] // patch_size) ** 2 # Number of patch embedding_dim = 64 # Number of hidden units. mlp_dim = 64 dim_coefficient = 4 num_heads = 4 attention_dropout = 0.2 projection_dropout = 0.2 num_transformer_blocks = 8 # Number of repetitions of the transformer layer print(f\"Patch size: {patch_size} X {patch_size} = {patch_size ** 2} \") print(f\"Patches per image: {num_patches}\") Patch size: 2 X 2 = 4 Patches per image: 256 Use data augmentation data_augmentation = keras.Sequential( [ layers.Normalization(), layers.RandomFlip(\"horizontal\"), layers.RandomRotation(factor=0.1), layers.RandomContrast(factor=0.1), layers.RandomZoom(height_factor=0.2, width_factor=0.2), ], name=\"data_augmentation\", ) # Compute the mean and the variance of the training data for normalization. data_augmentation.layers[0].adapt(x_train) Implement the patch extraction and encoding layer class PatchExtract(layers.Layer): def __init__(self, patch_size, **kwargs): super(PatchExtract, self).__init__(**kwargs) self.patch_size = patch_size def call(self, images): batch_size = tf.shape(images)[0] patches = tf.image.extract_patches( images=images, sizes=(1, self.patch_size, self.patch_size, 1), strides=(1, self.patch_size, self.patch_size, 1), rates=(1, 1, 1, 1), padding=\"VALID\", ) patch_dim = patches.shape[-1] patch_num = patches.shape[1] return tf.reshape(patches, (batch_size, patch_num * patch_num, patch_dim)) class PatchEmbedding(layers.Layer): def __init__(self, num_patch, embed_dim, **kwargs): super(PatchEmbedding, self).__init__(**kwargs) self.num_patch = num_patch self.proj = layers.Dense(embed_dim) self.pos_embed = layers.Embedding(input_dim=num_patch, output_dim=embed_dim) def call(self, patch): pos = tf.range(start=0, limit=self.num_patch, delta=1) return self.proj(patch) + self.pos_embed(pos) Implement the external attention block def external_attention( x, dim, num_heads, dim_coefficient=4, attention_dropout=0, projection_dropout=0 ): _, num_patch, channel = x.shape assert dim % num_heads == 0 num_heads = num_heads * dim_coefficient x = layers.Dense(dim * dim_coefficient)(x) # create tensor [batch_size, num_patches, num_heads, dim*dim_coefficient//num_heads] x = tf.reshape( x, shape=(-1, num_patch, num_heads, dim * dim_coefficient // num_heads) ) x = tf.transpose(x, perm=[0, 2, 1, 3]) # a linear layer M_k attn = layers.Dense(dim // dim_coefficient)(x) # normalize attention map attn = layers.Softmax(axis=2)(attn) # dobule-normalization attn = attn / (1e-9 + tf.reduce_sum(attn, axis=-1, keepdims=True)) attn = layers.Dropout(attention_dropout)(attn) # a linear layer M_v x = layers.Dense(dim * dim_coefficient // num_heads)(attn) x = tf.transpose(x, perm=[0, 2, 1, 3]) x = tf.reshape(x, [-1, num_patch, dim * dim_coefficient]) # a linear layer to project original dim x = layers.Dense(dim)(x) x = layers.Dropout(projection_dropout)(x) return x Implement the MLP block def mlp(x, embedding_dim, mlp_dim, drop_rate=0.2): x = layers.Dense(mlp_dim, activation=tf.nn.gelu)(x) x = layers.Dropout(drop_rate)(x) x = layers.Dense(embedding_dim)(x) x = layers.Dropout(drop_rate)(x) return x Implement the Transformer block def transformer_encoder( x, embedding_dim, mlp_dim, num_heads, dim_coefficient, attention_dropout, projection_dropout, attention_type=\"external_attention\", ): residual_1 = x x = layers.LayerNormalization(epsilon=1e-5)(x) if attention_type == \"external_attention\": x = external_attention( x, embedding_dim, num_heads, dim_coefficient, attention_dropout, projection_dropout, ) elif attention_type == \"self_attention\": x = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embedding_dim, dropout=attention_dropout )(x, x) x = layers.add([x, residual_1]) residual_2 = x x = layers.LayerNormalization(epsilon=1e-5)(x) x = mlp(x, embedding_dim, mlp_dim) x = layers.add([x, residual_2]) return x Implement the EANet model The EANet model leverages external attention. The computational complexity of traditional self attention is O(d * N ** 2), where d is the embedding size, and N is the number of patch. the authors find that most pixels are closely related to just a few other pixels, and an N-to-N attention matrix may be redundant. So, they propose as an alternative an external attention module where the computational complexity of external attention is O(d * S * N). As d and S are hyper-parameters, the proposed algorithm is linear in the number of pixels. In fact, this is equivalent to a drop patch operation, because a lot of information contained in a patch in an image is redundant and unimportant. def get_model(attention_type=\"external_attention\"): inputs = layers.Input(shape=input_shape) # Image augment x = data_augmentation(inputs) # Extract patches. x = PatchExtract(patch_size)(x) # Create patch embedding. x = PatchEmbedding(num_patches, embedding_dim)(x) # Create Transformer block. for _ in range(num_transformer_blocks): x = transformer_encoder( x, embedding_dim, mlp_dim, num_heads, dim_coefficient, attention_dropout, projection_dropout, attention_type, ) x = layers.GlobalAvgPool1D()(x) outputs = layers.Dense(num_classes, activation=\"softmax\")(x) model = keras.Model(inputs=inputs, outputs=outputs) return model Train on CIFAR-100 model = get_model(attention_type=\"external_attention\") model.compile( loss=keras.losses.CategoricalCrossentropy(label_smoothing=label_smoothing), optimizer=tfa.optimizers.AdamW( learning_rate=learning_rate, weight_decay=weight_decay ), metrics=[ keras.metrics.CategoricalAccuracy(name=\"accuracy\"), keras.metrics.TopKCategoricalAccuracy(5, name=\"top-5-accuracy\"), ], ) history = model.fit( x_train, y_train, batch_size=batch_size, epochs=num_epochs, validation_split=validation_split, ) Epoch 1/50 313/313 [==============================] - 40s 95ms/step - loss: 4.2091 - accuracy: 0.0723 - top-5-accuracy: 0.2384 - val_loss: 3.9706 - val_accuracy: 0.1153 - val_top-5-accuracy: 0.3336 Epoch 2/50 313/313 [==============================] - 29s 91ms/step - loss: 3.8028 - accuracy: 0.1427 - top-5-accuracy: 0.3871 - val_loss: 3.6672 - val_accuracy: 0.1829 - val_top-5-accuracy: 0.4513 Epoch 3/50 313/313 [==============================] - 29s 93ms/step - loss: 3.5493 - accuracy: 0.1978 - top-5-accuracy: 0.4805 - val_loss: 3.5402 - val_accuracy: 0.2141 - val_top-5-accuracy: 0.5038 Epoch 4/50 313/313 [==============================] - 29s 93ms/step - loss: 3.4029 - accuracy: 0.2355 - top-5-accuracy: 0.5328 - val_loss: 3.4496 - val_accuracy: 0.2354 - val_top-5-accuracy: 0.5316 Epoch 5/50 313/313 [==============================] - 29s 92ms/step - loss: 3.2917 - accuracy: 0.2636 - top-5-accuracy: 0.5678 - val_loss: 3.3342 - val_accuracy: 0.2699 - val_top-5-accuracy: 0.5679 Epoch 6/50 313/313 [==============================] - 29s 92ms/step - loss: 3.2116 - accuracy: 0.2830 - top-5-accuracy: 0.5921 - val_loss: 3.2896 - val_accuracy: 0.2749 - val_top-5-accuracy: 0.5874 Epoch 7/50 313/313 [==============================] - 28s 90ms/step - loss: 3.1453 - accuracy: 0.2980 - top-5-accuracy: 0.6100 - val_loss: 3.3090 - val_accuracy: 0.2857 - val_top-5-accuracy: 0.5831 Epoch 8/50 313/313 [==============================] - 29s 94ms/step - loss: 3.0889 - accuracy: 0.3121 - top-5-accuracy: 0.6266 - val_loss: 3.1969 - val_accuracy: 0.2975 - val_top-5-accuracy: 0.6082 Epoch 9/50 313/313 [==============================] - 29s 92ms/step - loss: 3.0390 - accuracy: 0.3252 - top-5-accuracy: 0.6441 - val_loss: 3.1249 - val_accuracy: 0.3175 - val_top-5-accuracy: 0.6330 Epoch 10/50 313/313 [==============================] - 29s 92ms/step - loss: 2.9871 - accuracy: 0.3365 - top-5-accuracy: 0.6615 - val_loss: 3.1121 - val_accuracy: 0.3200 - val_top-5-accuracy: 0.6374 Epoch 11/50 313/313 [==============================] - 29s 92ms/step - loss: 2.9476 - accuracy: 0.3489 - top-5-accuracy: 0.6697 - val_loss: 3.1156 - val_accuracy: 0.3268 - val_top-5-accuracy: 0.6421 Epoch 12/50 313/313 [==============================] - 29s 91ms/step - loss: 2.9106 - accuracy: 0.3576 - top-5-accuracy: 0.6783 - val_loss: 3.1337 - val_accuracy: 0.3226 - val_top-5-accuracy: 0.6389 Epoch 13/50 313/313 [==============================] - 29s 92ms/step - loss: 2.8772 - accuracy: 0.3662 - top-5-accuracy: 0.6871 - val_loss: 3.0373 - val_accuracy: 0.3348 - val_top-5-accuracy: 0.6624 Epoch 14/50 313/313 [==============================] - 29s 92ms/step - loss: 2.8508 - accuracy: 0.3756 - top-5-accuracy: 0.6944 - val_loss: 3.0297 - val_accuracy: 0.3441 - val_top-5-accuracy: 0.6643 Epoch 15/50 313/313 [==============================] - 28s 90ms/step - loss: 2.8211 - accuracy: 0.3821 - top-5-accuracy: 0.7034 - val_loss: 2.9680 - val_accuracy: 0.3604 - val_top-5-accuracy: 0.6847 Epoch 16/50 313/313 [==============================] - 28s 90ms/step - loss: 2.8017 - accuracy: 0.3864 - top-5-accuracy: 0.7090 - val_loss: 2.9746 - val_accuracy: 0.3584 - val_top-5-accuracy: 0.6855 Epoch 17/50 313/313 [==============================] - 29s 91ms/step - loss: 2.7714 - accuracy: 0.3962 - top-5-accuracy: 0.7169 - val_loss: 2.9104 - val_accuracy: 0.3738 - val_top-5-accuracy: 0.6940 Epoch 18/50 313/313 [==============================] - 29s 92ms/step - loss: 2.7523 - accuracy: 0.4008 - top-5-accuracy: 0.7204 - val_loss: 2.8560 - val_accuracy: 0.3861 - val_top-5-accuracy: 0.7115 Epoch 19/50 313/313 [==============================] - 28s 91ms/step - loss: 2.7320 - accuracy: 0.4051 - top-5-accuracy: 0.7263 - val_loss: 2.8780 - val_accuracy: 0.3820 - val_top-5-accuracy: 0.7101 Epoch 20/50 313/313 [==============================] - 28s 90ms/step - loss: 2.7139 - accuracy: 0.4114 - top-5-accuracy: 0.7290 - val_loss: 2.9831 - val_accuracy: 0.3694 - val_top-5-accuracy: 0.6922 Epoch 21/50 313/313 [==============================] - 28s 91ms/step - loss: 2.6991 - accuracy: 0.4142 - top-5-accuracy: 0.7335 - val_loss: 2.8420 - val_accuracy: 0.3968 - val_top-5-accuracy: 0.7138 Epoch 22/50 313/313 [==============================] - 29s 91ms/step - loss: 2.6842 - accuracy: 0.4195 - top-5-accuracy: 0.7377 - val_loss: 2.7965 - val_accuracy: 0.4088 - val_top-5-accuracy: 0.7266 Epoch 23/50 313/313 [==============================] - 28s 91ms/step - loss: 2.6571 - accuracy: 0.4273 - top-5-accuracy: 0.7436 - val_loss: 2.8620 - val_accuracy: 0.3947 - val_top-5-accuracy: 0.7155 Epoch 24/50 313/313 [==============================] - 29s 91ms/step - loss: 2.6508 - accuracy: 0.4277 - top-5-accuracy: 0.7469 - val_loss: 2.8459 - val_accuracy: 0.3963 - val_top-5-accuracy: 0.7150 Epoch 25/50 313/313 [==============================] - 28s 90ms/step - loss: 2.6403 - accuracy: 0.4283 - top-5-accuracy: 0.7520 - val_loss: 2.7886 - val_accuracy: 0.4128 - val_top-5-accuracy: 0.7283 Epoch 26/50 313/313 [==============================] - 29s 92ms/step - loss: 2.6281 - accuracy: 0.4353 - top-5-accuracy: 0.7523 - val_loss: 2.8493 - val_accuracy: 0.4026 - val_top-5-accuracy: 0.7153 Epoch 27/50 313/313 [==============================] - 29s 92ms/step - loss: 2.6092 - accuracy: 0.4403 - top-5-accuracy: 0.7580 - val_loss: 2.7539 - val_accuracy: 0.4186 - val_top-5-accuracy: 0.7392 Epoch 28/50 313/313 [==============================] - 29s 91ms/step - loss: 2.5992 - accuracy: 0.4423 - top-5-accuracy: 0.7600 - val_loss: 2.8625 - val_accuracy: 0.3964 - val_top-5-accuracy: 0.7174 Epoch 29/50 313/313 [==============================] - 28s 90ms/step - loss: 2.5913 - accuracy: 0.4456 - top-5-accuracy: 0.7598 - val_loss: 2.7911 - val_accuracy: 0.4162 - val_top-5-accuracy: 0.7329 Epoch 30/50 313/313 [==============================] - 29s 92ms/step - loss: 2.5780 - accuracy: 0.4480 - top-5-accuracy: 0.7649 - val_loss: 2.8158 - val_accuracy: 0.4118 - val_top-5-accuracy: 0.7288 Epoch 31/50 313/313 [==============================] - 28s 91ms/step - loss: 2.5657 - accuracy: 0.4547 - top-5-accuracy: 0.7661 - val_loss: 2.8651 - val_accuracy: 0.4056 - val_top-5-accuracy: 0.7217 Epoch 32/50 313/313 [==============================] - 29s 91ms/step - loss: 2.5637 - accuracy: 0.4480 - top-5-accuracy: 0.7681 - val_loss: 2.8190 - val_accuracy: 0.4094 - val_top-5-accuracy: 0.7267 Epoch 33/50 313/313 [==============================] - 29s 92ms/step - loss: 2.5525 - accuracy: 0.4545 - top-5-accuracy: 0.7693 - val_loss: 2.7985 - val_accuracy: 0.4216 - val_top-5-accuracy: 0.7303 Epoch 34/50 313/313 [==============================] - 28s 91ms/step - loss: 2.5462 - accuracy: 0.4579 - top-5-accuracy: 0.7721 - val_loss: 2.8865 - val_accuracy: 0.4016 - val_top-5-accuracy: 0.7204 Epoch 35/50 313/313 [==============================] - 29s 92ms/step - loss: 2.5329 - accuracy: 0.4616 - top-5-accuracy: 0.7740 - val_loss: 2.7862 - val_accuracy: 0.4232 - val_top-5-accuracy: 0.7389 Epoch 36/50 313/313 [==============================] - 28s 90ms/step - loss: 2.5234 - accuracy: 0.4610 - top-5-accuracy: 0.7765 - val_loss: 2.8234 - val_accuracy: 0.4134 - val_top-5-accuracy: 0.7312 Epoch 37/50 313/313 [==============================] - 29s 91ms/step - loss: 2.5152 - accuracy: 0.4663 - top-5-accuracy: 0.7774 - val_loss: 2.7894 - val_accuracy: 0.4161 - val_top-5-accuracy: 0.7376 Epoch 38/50 313/313 [==============================] - 29s 92ms/step - loss: 2.5117 - accuracy: 0.4674 - top-5-accuracy: 0.7790 - val_loss: 2.8091 - val_accuracy: 0.4142 - val_top-5-accuracy: 0.7360 Epoch 39/50 313/313 [==============================] - 28s 90ms/step - loss: 2.5047 - accuracy: 0.4681 - top-5-accuracy: 0.7805 - val_loss: 2.8199 - val_accuracy: 0.4167 - val_top-5-accuracy: 0.7299 Epoch 40/50 313/313 [==============================] - 28s 90ms/step - loss: 2.4974 - accuracy: 0.4697 - top-5-accuracy: 0.7819 - val_loss: 2.7864 - val_accuracy: 0.4247 - val_top-5-accuracy: 0.7402 Epoch 41/50 313/313 [==============================] - 28s 90ms/step - loss: 2.4889 - accuracy: 0.4749 - top-5-accuracy: 0.7854 - val_loss: 2.8120 - val_accuracy: 0.4217 - val_top-5-accuracy: 0.7358 Epoch 42/50 313/313 [==============================] - 28s 90ms/step - loss: 2.4799 - accuracy: 0.4771 - top-5-accuracy: 0.7866 - val_loss: 2.9003 - val_accuracy: 0.4038 - val_top-5-accuracy: 0.7170 Epoch 43/50 313/313 [==============================] - 28s 90ms/step - loss: 2.4814 - accuracy: 0.4770 - top-5-accuracy: 0.7868 - val_loss: 2.7504 - val_accuracy: 0.4260 - val_top-5-accuracy: 0.7457 Epoch 44/50 313/313 [==============================] - 28s 91ms/step - loss: 2.4747 - accuracy: 0.4757 - top-5-accuracy: 0.7870 - val_loss: 2.8207 - val_accuracy: 0.4166 - val_top-5-accuracy: 0.7363 Epoch 45/50 313/313 [==============================] - 28s 90ms/step - loss: 2.4653 - accuracy: 0.4809 - top-5-accuracy: 0.7924 - val_loss: 2.8663 - val_accuracy: 0.4130 - val_top-5-accuracy: 0.7209 Epoch 46/50 313/313 [==============================] - 28s 90ms/step - loss: 2.4554 - accuracy: 0.4825 - top-5-accuracy: 0.7929 - val_loss: 2.8145 - val_accuracy: 0.4250 - val_top-5-accuracy: 0.7357 Epoch 47/50 313/313 [==============================] - 29s 91ms/step - loss: 2.4602 - accuracy: 0.4823 - top-5-accuracy: 0.7919 - val_loss: 2.8352 - val_accuracy: 0.4189 - val_top-5-accuracy: 0.7365 Epoch 48/50 313/313 [==============================] - 28s 91ms/step - loss: 2.4493 - accuracy: 0.4848 - top-5-accuracy: 0.7933 - val_loss: 2.8246 - val_accuracy: 0.4160 - val_top-5-accuracy: 0.7362 Epoch 49/50 313/313 [==============================] - 28s 91ms/step - loss: 2.4454 - accuracy: 0.4846 - top-5-accuracy: 0.7958 - val_loss: 2.7731 - val_accuracy: 0.4320 - val_top-5-accuracy: 0.7436 Epoch 50/50 313/313 [==============================] - 29s 92ms/step - loss: 2.4418 - accuracy: 0.4848 - top-5-accuracy: 0.7951 - val_loss: 2.7926 - val_accuracy: 0.4317 - val_top-5-accuracy: 0.7410 Let's visualize the training progress of the model. plt.plot(history.history[\"loss\"], label=\"train_loss\") plt.plot(history.history[\"val_loss\"], label=\"val_loss\") plt.xlabel(\"Epochs\") plt.ylabel(\"Loss\") plt.title(\"Train and Validation Losses Over Epochs\", fontsize=14) plt.legend() plt.grid() plt.show() png Let's display the final results of the test on CIFAR-100. loss, accuracy, top_5_accuracy = model.evaluate(x_test, y_test) print(f\"Test loss: {round(loss, 2)}\") print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") print(f\"Test top 5 accuracy: {round(top_5_accuracy * 100, 2)}%\") 313/313 [==============================] - 6s 21ms/step - loss: 2.7574 - accuracy: 0.4391 - top-5-accuracy: 0.7471 Test loss: 2.76 Test accuracy: 43.91% Test top 5 accuracy: 74.71% EANet just replaces self attention in Vit with external attention. The traditional Vit achieved a ~73% test top-5 accuracy and ~41 top-1 accuracy after training 50 epochs, but with 0.6M parameters. Under the same experimental environment and the same hyperparameters, The EANet model we just trained has just 0.3M parameters, and it gets us to ~73% test top-5 accuracy and ~43% top-1 accuracy. This fully demonstrates the effectiveness of external attention. We only show the training process of EANet, you can train Vit under the same experimental conditions and observe the test results. Implementing the MLP-Mixer, FNet, and gMLP models for CIFAR-100 image classification. Introduction This example implements three modern attention-free, multi-layer perceptron (MLP) based models for image classification, demonstrated on the CIFAR-100 dataset: The MLP-Mixer model, by Ilya Tolstikhin et al., based on two types of MLPs. The FNet model, by James Lee-Thorp et al., based on unparameterized Fourier Transform. The gMLP model, by Hanxiao Liu et al., based on MLP with gating. The purpose of the example is not to compare between these models, as they might perform differently on different datasets with well-tuned hyperparameters. Rather, it is to show simple implementations of their main building blocks. This example requires TensorFlow 2.4 or higher, as well as TensorFlow Addons, which can be installed using the following command: pip install -U tensorflow-addons Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_addons as tfa Prepare the data num_classes = 100 input_shape = (32, 32, 3) (x_train, y_train), (x_test, y_test) = keras.datasets.cifar100.load_data() print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\") print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\") x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 1) x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 1) Configure the hyperparameters weight_decay = 0.0001 batch_size = 128 num_epochs = 50 dropout_rate = 0.2 image_size = 64 # We'll resize input images to this size. patch_size = 8 # Size of the patches to be extracted from the input images. num_patches = (image_size // patch_size) ** 2 # Size of the data array. embedding_dim = 256 # Number of hidden units. num_blocks = 4 # Number of blocks. print(f\"Image size: {image_size} X {image_size} = {image_size ** 2}\") print(f\"Patch size: {patch_size} X {patch_size} = {patch_size ** 2} \") print(f\"Patches per image: {num_patches}\") print(f\"Elements per patch (3 channels): {(patch_size ** 2) * 3}\") Image size: 64 X 64 = 4096 Patch size: 8 X 8 = 64 Patches per image: 64 Elements per patch (3 channels): 192 Build a classification model We implement a method that builds a classifier given the processing blocks. def build_classifier(blocks, positional_encoding=False): inputs = layers.Input(shape=input_shape) # Augment data. augmented = data_augmentation(inputs) # Create patches. patches = Patches(patch_size, num_patches)(augmented) # Encode patches to generate a [batch_size, num_patches, embedding_dim] tensor. x = layers.Dense(units=embedding_dim)(patches) if positional_encoding: positions = tf.range(start=0, limit=num_patches, delta=1) position_embedding = layers.Embedding( input_dim=num_patches, output_dim=embedding_dim )(positions) x = x + position_embedding # Process x using the module blocks. x = blocks(x) # Apply global average pooling to generate a [batch_size, embedding_dim] representation tensor. representation = layers.GlobalAveragePooling1D()(x) # Apply dropout. representation = layers.Dropout(rate=dropout_rate)(representation) # Compute logits outputs. logits = layers.Dense(num_classes)(representation) # Create the Keras model. return keras.Model(inputs=inputs, outputs=logits) Define an experiment We implement a utility function to compile, train, and evaluate a given model. def run_experiment(model): # Create Adam optimizer with weight decay. optimizer = tfa.optimizers.AdamW( learning_rate=learning_rate, weight_decay=weight_decay, ) # Compile the model. model.compile( optimizer=optimizer, loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[ keras.metrics.SparseCategoricalAccuracy(name=\"acc\"), keras.metrics.SparseTopKCategoricalAccuracy(5, name=\"top5-acc\"), ], ) # Create a learning rate scheduler callback. reduce_lr = keras.callbacks.ReduceLROnPlateau( monitor=\"val_loss\", factor=0.5, patience=5 ) # Create an early stopping callback. early_stopping = tf.keras.callbacks.EarlyStopping( monitor=\"val_loss\", patience=10, restore_best_weights=True ) # Fit the model. history = model.fit( x=x_train, y=y_train, batch_size=batch_size, epochs=num_epochs, validation_split=0.1, callbacks=[early_stopping, reduce_lr], ) _, accuracy, top_5_accuracy = model.evaluate(x_test, y_test) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") print(f\"Test top 5 accuracy: {round(top_5_accuracy * 100, 2)}%\") # Return history to plot learning curves. return history Use data augmentation data_augmentation = keras.Sequential( [ layers.Normalization(), layers.Resizing(image_size, image_size), layers.RandomFlip(\"horizontal\"), layers.RandomZoom( height_factor=0.2, width_factor=0.2 ), ], name=\"data_augmentation\", ) # Compute the mean and the variance of the training data for normalization. data_augmentation.layers[0].adapt(x_train) Implement patch extraction as a layer class Patches(layers.Layer): def __init__(self, patch_size, num_patches): super(Patches, self).__init__() self.patch_size = patch_size self.num_patches = num_patches def call(self, images): batch_size = tf.shape(images)[0] patches = tf.image.extract_patches( images=images, sizes=[1, self.patch_size, self.patch_size, 1], strides=[1, self.patch_size, self.patch_size, 1], rates=[1, 1, 1, 1], padding=\"VALID\", ) patch_dims = patches.shape[-1] patches = tf.reshape(patches, [batch_size, self.num_patches, patch_dims]) return patches The MLP-Mixer model The MLP-Mixer is an architecture based exclusively on multi-layer perceptrons (MLPs), that contains two types of MLP layers: One applied independently to image patches, which mixes the per-location features. The other applied across patches (along channels), which mixes spatial information. This is similar to a depthwise separable convolution based model such as the Xception model, but with two chained dense transforms, no max pooling, and layer normalization instead of batch normalization. Implement the MLP-Mixer module class MLPMixerLayer(layers.Layer): def __init__(self, num_patches, hidden_units, dropout_rate, *args, **kwargs): super(MLPMixerLayer, self).__init__(*args, **kwargs) self.mlp1 = keras.Sequential( [ layers.Dense(units=num_patches), tfa.layers.GELU(), layers.Dense(units=num_patches), layers.Dropout(rate=dropout_rate), ] ) self.mlp2 = keras.Sequential( [ layers.Dense(units=num_patches), tfa.layers.GELU(), layers.Dense(units=embedding_dim), layers.Dropout(rate=dropout_rate), ] ) self.normalize = layers.LayerNormalization(epsilon=1e-6) def call(self, inputs): # Apply layer normalization. x = self.normalize(inputs) # Transpose inputs from [num_batches, num_patches, hidden_units] to [num_batches, hidden_units, num_patches]. x_channels = tf.linalg.matrix_transpose(x) # Apply mlp1 on each channel independently. mlp1_outputs = self.mlp1(x_channels) # Transpose mlp1_outputs from [num_batches, hidden_dim, num_patches] to [num_batches, num_patches, hidden_units]. mlp1_outputs = tf.linalg.matrix_transpose(mlp1_outputs) # Add skip connection. x = mlp1_outputs + inputs # Apply layer normalization. x_patches = self.normalize(x) # Apply mlp2 on each patch independtenly. mlp2_outputs = self.mlp2(x_patches) # Add skip connection. x = x + mlp2_outputs return x Build, train, and evaluate the MLP-Mixer model Note that training the model with the current settings on a V100 GPUs takes around 8 seconds per epoch. mlpmixer_blocks = keras.Sequential( [MLPMixerLayer(num_patches, embedding_dim, dropout_rate) for _ in range(num_blocks)] ) learning_rate = 0.005 mlpmixer_classifier = build_classifier(mlpmixer_blocks) history = run_experiment(mlpmixer_classifier) /opt/conda/lib/python3.7/site-packages/tensorflow/python/autograph/impl/api.py:390: UserWarning: Default value of `approximate` is changed from `True` to `False` return py_builtins.overload_of(f)(*args) Epoch 1/50 352/352 [==============================] - 13s 25ms/step - loss: 4.1703 - acc: 0.0756 - top5-acc: 0.2322 - val_loss: 3.6202 - val_acc: 0.1532 - val_top5-acc: 0.4140 Epoch 2/50 352/352 [==============================] - 8s 23ms/step - loss: 3.4165 - acc: 0.1789 - top5-acc: 0.4459 - val_loss: 3.1599 - val_acc: 0.2334 - val_top5-acc: 0.5160 Epoch 3/50 352/352 [==============================] - 8s 23ms/step - loss: 3.1367 - acc: 0.2328 - top5-acc: 0.5230 - val_loss: 3.0539 - val_acc: 0.2560 - val_top5-acc: 0.5664 Epoch 4/50 352/352 [==============================] - 8s 23ms/step - loss: 2.9985 - acc: 0.2624 - top5-acc: 0.5600 - val_loss: 2.9498 - val_acc: 0.2798 - val_top5-acc: 0.5856 Epoch 5/50 352/352 [==============================] - 8s 23ms/step - loss: 2.8806 - acc: 0.2809 - top5-acc: 0.5879 - val_loss: 2.8593 - val_acc: 0.2904 - val_top5-acc: 0.6050 Epoch 6/50 352/352 [==============================] - 8s 23ms/step - loss: 2.7860 - acc: 0.3024 - top5-acc: 0.6124 - val_loss: 2.7405 - val_acc: 0.3256 - val_top5-acc: 0.6364 Epoch 7/50 352/352 [==============================] - 8s 23ms/step - loss: 2.7065 - acc: 0.3152 - top5-acc: 0.6280 - val_loss: 2.7548 - val_acc: 0.3328 - val_top5-acc: 0.6450 Epoch 8/50 352/352 [==============================] - 8s 22ms/step - loss: 2.6443 - acc: 0.3263 - top5-acc: 0.6446 - val_loss: 2.6618 - val_acc: 0.3460 - val_top5-acc: 0.6578 Epoch 9/50 352/352 [==============================] - 8s 23ms/step - loss: 2.5886 - acc: 0.3406 - top5-acc: 0.6573 - val_loss: 2.6065 - val_acc: 0.3492 - val_top5-acc: 0.6650 Epoch 10/50 352/352 [==============================] - 8s 23ms/step - loss: 2.5798 - acc: 0.3404 - top5-acc: 0.6591 - val_loss: 2.6546 - val_acc: 0.3502 - val_top5-acc: 0.6630 Epoch 11/50 352/352 [==============================] - 8s 23ms/step - loss: 2.5269 - acc: 0.3498 - top5-acc: 0.6714 - val_loss: 2.6201 - val_acc: 0.3570 - val_top5-acc: 0.6710 Epoch 12/50 352/352 [==============================] - 8s 23ms/step - loss: 2.5003 - acc: 0.3569 - top5-acc: 0.6745 - val_loss: 2.5936 - val_acc: 0.3564 - val_top5-acc: 0.6662 Epoch 13/50 352/352 [==============================] - 8s 22ms/step - loss: 2.4801 - acc: 0.3619 - top5-acc: 0.6792 - val_loss: 2.5236 - val_acc: 0.3700 - val_top5-acc: 0.6786 Epoch 14/50 352/352 [==============================] - 8s 23ms/step - loss: 2.4392 - acc: 0.3676 - top5-acc: 0.6879 - val_loss: 2.4971 - val_acc: 0.3808 - val_top5-acc: 0.6926 Epoch 15/50 352/352 [==============================] - 8s 23ms/step - loss: 2.4073 - acc: 0.3790 - top5-acc: 0.6940 - val_loss: 2.5972 - val_acc: 0.3682 - val_top5-acc: 0.6750 Epoch 16/50 352/352 [==============================] - 8s 23ms/step - loss: 2.3922 - acc: 0.3754 - top5-acc: 0.6980 - val_loss: 2.4317 - val_acc: 0.3964 - val_top5-acc: 0.6992 Epoch 17/50 352/352 [==============================] - 8s 22ms/step - loss: 2.3603 - acc: 0.3891 - top5-acc: 0.7038 - val_loss: 2.4844 - val_acc: 0.3766 - val_top5-acc: 0.6964 Epoch 18/50 352/352 [==============================] - 8s 23ms/step - loss: 2.3560 - acc: 0.3849 - top5-acc: 0.7056 - val_loss: 2.4564 - val_acc: 0.3910 - val_top5-acc: 0.6990 Epoch 19/50 352/352 [==============================] - 8s 23ms/step - loss: 2.3367 - acc: 0.3900 - top5-acc: 0.7069 - val_loss: 2.4282 - val_acc: 0.3906 - val_top5-acc: 0.7058 Epoch 20/50 352/352 [==============================] - 8s 22ms/step - loss: 2.3096 - acc: 0.3945 - top5-acc: 0.7180 - val_loss: 2.4297 - val_acc: 0.3930 - val_top5-acc: 0.7082 Epoch 21/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2935 - acc: 0.3996 - top5-acc: 0.7211 - val_loss: 2.4053 - val_acc: 0.3974 - val_top5-acc: 0.7076 Epoch 22/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2823 - acc: 0.3991 - top5-acc: 0.7248 - val_loss: 2.4756 - val_acc: 0.3920 - val_top5-acc: 0.6988 Epoch 23/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2371 - acc: 0.4126 - top5-acc: 0.7294 - val_loss: 2.3802 - val_acc: 0.3972 - val_top5-acc: 0.7100 Epoch 24/50 352/352 [==============================] - 8s 23ms/step - loss: 2.2234 - acc: 0.4140 - top5-acc: 0.7336 - val_loss: 2.4402 - val_acc: 0.3994 - val_top5-acc: 0.7096 Epoch 25/50 352/352 [==============================] - 8s 23ms/step - loss: 2.2320 - acc: 0.4088 - top5-acc: 0.7333 - val_loss: 2.4343 - val_acc: 0.3936 - val_top5-acc: 0.7052 Epoch 26/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2094 - acc: 0.4193 - top5-acc: 0.7347 - val_loss: 2.4154 - val_acc: 0.4058 - val_top5-acc: 0.7192 Epoch 27/50 352/352 [==============================] - 8s 23ms/step - loss: 2.2029 - acc: 0.4180 - top5-acc: 0.7370 - val_loss: 2.3116 - val_acc: 0.4226 - val_top5-acc: 0.7268 Epoch 28/50 352/352 [==============================] - 8s 23ms/step - loss: 2.1959 - acc: 0.4234 - top5-acc: 0.7380 - val_loss: 2.4053 - val_acc: 0.4064 - val_top5-acc: 0.7168 Epoch 29/50 352/352 [==============================] - 8s 23ms/step - loss: 2.1815 - acc: 0.4227 - top5-acc: 0.7415 - val_loss: 2.4020 - val_acc: 0.4078 - val_top5-acc: 0.7192 Epoch 30/50 352/352 [==============================] - 8s 23ms/step - loss: 2.1783 - acc: 0.4245 - top5-acc: 0.7407 - val_loss: 2.4206 - val_acc: 0.3996 - val_top5-acc: 0.7234 Epoch 31/50 352/352 [==============================] - 8s 22ms/step - loss: 2.1686 - acc: 0.4248 - top5-acc: 0.7442 - val_loss: 2.3743 - val_acc: 0.4100 - val_top5-acc: 0.7162 Epoch 32/50 352/352 [==============================] - 8s 23ms/step - loss: 2.1487 - acc: 0.4317 - top5-acc: 0.7472 - val_loss: 2.3882 - val_acc: 0.4018 - val_top5-acc: 0.7266 Epoch 33/50 352/352 [==============================] - 8s 22ms/step - loss: 1.9836 - acc: 0.4644 - top5-acc: 0.7782 - val_loss: 2.1742 - val_acc: 0.4536 - val_top5-acc: 0.7506 Epoch 34/50 352/352 [==============================] - 8s 23ms/step - loss: 1.8723 - acc: 0.4950 - top5-acc: 0.7985 - val_loss: 2.1716 - val_acc: 0.4506 - val_top5-acc: 0.7546 Epoch 35/50 352/352 [==============================] - 8s 23ms/step - loss: 1.8461 - acc: 0.5009 - top5-acc: 0.8003 - val_loss: 2.1661 - val_acc: 0.4480 - val_top5-acc: 0.7542 Epoch 36/50 352/352 [==============================] - 8s 23ms/step - loss: 1.8499 - acc: 0.4944 - top5-acc: 0.8044 - val_loss: 2.1523 - val_acc: 0.4566 - val_top5-acc: 0.7628 Epoch 37/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8322 - acc: 0.5000 - top5-acc: 0.8059 - val_loss: 2.1334 - val_acc: 0.4570 - val_top5-acc: 0.7560 Epoch 38/50 352/352 [==============================] - 8s 23ms/step - loss: 1.8269 - acc: 0.5027 - top5-acc: 0.8085 - val_loss: 2.1024 - val_acc: 0.4614 - val_top5-acc: 0.7674 Epoch 39/50 352/352 [==============================] - 8s 23ms/step - loss: 1.8242 - acc: 0.4990 - top5-acc: 0.8098 - val_loss: 2.0789 - val_acc: 0.4610 - val_top5-acc: 0.7792 Epoch 40/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7983 - acc: 0.5067 - top5-acc: 0.8122 - val_loss: 2.1514 - val_acc: 0.4546 - val_top5-acc: 0.7628 Epoch 41/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7974 - acc: 0.5112 - top5-acc: 0.8132 - val_loss: 2.1425 - val_acc: 0.4542 - val_top5-acc: 0.7630 Epoch 42/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7972 - acc: 0.5128 - top5-acc: 0.8127 - val_loss: 2.0980 - val_acc: 0.4580 - val_top5-acc: 0.7724 Epoch 43/50 352/352 [==============================] - 8s 23ms/step - loss: 1.8026 - acc: 0.5066 - top5-acc: 0.8115 - val_loss: 2.0922 - val_acc: 0.4684 - val_top5-acc: 0.7678 Epoch 44/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7924 - acc: 0.5092 - top5-acc: 0.8129 - val_loss: 2.0511 - val_acc: 0.4750 - val_top5-acc: 0.7726 Epoch 45/50 352/352 [==============================] - 8s 22ms/step - loss: 1.7695 - acc: 0.5106 - top5-acc: 0.8193 - val_loss: 2.0949 - val_acc: 0.4678 - val_top5-acc: 0.7708 Epoch 46/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7784 - acc: 0.5106 - top5-acc: 0.8141 - val_loss: 2.1094 - val_acc: 0.4656 - val_top5-acc: 0.7704 Epoch 47/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7625 - acc: 0.5155 - top5-acc: 0.8190 - val_loss: 2.0492 - val_acc: 0.4774 - val_top5-acc: 0.7744 Epoch 48/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7441 - acc: 0.5217 - top5-acc: 0.8190 - val_loss: 2.0562 - val_acc: 0.4698 - val_top5-acc: 0.7828 Epoch 49/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7665 - acc: 0.5113 - top5-acc: 0.8196 - val_loss: 2.0348 - val_acc: 0.4708 - val_top5-acc: 0.7730 Epoch 50/50 352/352 [==============================] - 8s 23ms/step - loss: 1.7392 - acc: 0.5201 - top5-acc: 0.8226 - val_loss: 2.0787 - val_acc: 0.4710 - val_top5-acc: 0.7734 313/313 [==============================] - 2s 8ms/step - loss: 2.0571 - acc: 0.4758 - top5-acc: 0.7718 Test accuracy: 47.58% Test top 5 accuracy: 77.18% The MLP-Mixer model tends to have much less number of parameters compared to convolutional and transformer-based models, which leads to less training and serving computational cost. As mentioned in the MLP-Mixer paper, when pre-trained on large datasets, or with modern regularization schemes, the MLP-Mixer attains competitive scores to state-of-the-art models. You can obtain better results by increasing the embedding dimensions, increasing, increasing the number of mixer blocks, and training the model for longer. You may also try to increase the size of the input images and use different patch sizes. The FNet model The FNet uses a similar block to the Transformer block. However, FNet replaces the self-attention layer in the Transformer block with a parameter-free 2D Fourier transformation layer: One 1D Fourier Transform is applied along the patches. One 1D Fourier Transform is applied along the channels. Implement the FNet module class FNetLayer(layers.Layer): def __init__(self, num_patches, embedding_dim, dropout_rate, *args, **kwargs): super(FNetLayer, self).__init__(*args, **kwargs) self.ffn = keras.Sequential( [ layers.Dense(units=embedding_dim), tfa.layers.GELU(), layers.Dropout(rate=dropout_rate), layers.Dense(units=embedding_dim), ] ) self.normalize1 = layers.LayerNormalization(epsilon=1e-6) self.normalize2 = layers.LayerNormalization(epsilon=1e-6) def call(self, inputs): # Apply fourier transformations. x = tf.cast( tf.signal.fft2d(tf.cast(inputs, dtype=tf.dtypes.complex64)), dtype=tf.dtypes.float32, ) # Add skip connection. x = x + inputs # Apply layer normalization. x = self.normalize1(x) # Apply Feedfowrad network. x_ffn = self.ffn(x) # Add skip connection. x = x + x_ffn # Apply layer normalization. return self.normalize2(x) Build, train, and evaluate the FNet model Note that training the model with the current settings on a V100 GPUs takes around 8 seconds per epoch. fnet_blocks = keras.Sequential( [FNetLayer(num_patches, embedding_dim, dropout_rate) for _ in range(num_blocks)] ) learning_rate = 0.001 fnet_classifier = build_classifier(fnet_blocks, positional_encoding=True) history = run_experiment(fnet_classifier) Epoch 1/50 352/352 [==============================] - 11s 23ms/step - loss: 4.3419 - acc: 0.0470 - top5-acc: 0.1652 - val_loss: 3.8279 - val_acc: 0.1178 - val_top5-acc: 0.3268 Epoch 2/50 352/352 [==============================] - 8s 22ms/step - loss: 3.7814 - acc: 0.1202 - top5-acc: 0.3341 - val_loss: 3.5981 - val_acc: 0.1540 - val_top5-acc: 0.3914 Epoch 3/50 352/352 [==============================] - 8s 22ms/step - loss: 3.5319 - acc: 0.1603 - top5-acc: 0.4086 - val_loss: 3.3309 - val_acc: 0.1956 - val_top5-acc: 0.4656 Epoch 4/50 352/352 [==============================] - 8s 22ms/step - loss: 3.3025 - acc: 0.2001 - top5-acc: 0.4730 - val_loss: 3.1215 - val_acc: 0.2334 - val_top5-acc: 0.5234 Epoch 5/50 352/352 [==============================] - 8s 22ms/step - loss: 3.1621 - acc: 0.2224 - top5-acc: 0.5084 - val_loss: 3.0492 - val_acc: 0.2456 - val_top5-acc: 0.5322 Epoch 6/50 352/352 [==============================] - 8s 22ms/step - loss: 3.0506 - acc: 0.2469 - top5-acc: 0.5400 - val_loss: 2.9519 - val_acc: 0.2684 - val_top5-acc: 0.5652 Epoch 7/50 352/352 [==============================] - 8s 22ms/step - loss: 2.9520 - acc: 0.2618 - top5-acc: 0.5677 - val_loss: 2.8936 - val_acc: 0.2688 - val_top5-acc: 0.5864 Epoch 8/50 352/352 [==============================] - 8s 22ms/step - loss: 2.8377 - acc: 0.2828 - top5-acc: 0.5938 - val_loss: 2.7633 - val_acc: 0.2996 - val_top5-acc: 0.6068 Epoch 9/50 352/352 [==============================] - 8s 22ms/step - loss: 2.7670 - acc: 0.2969 - top5-acc: 0.6107 - val_loss: 2.7309 - val_acc: 0.3112 - val_top5-acc: 0.6136 Epoch 10/50 352/352 [==============================] - 8s 22ms/step - loss: 2.7027 - acc: 0.3148 - top5-acc: 0.6231 - val_loss: 2.6552 - val_acc: 0.3214 - val_top5-acc: 0.6436 Epoch 11/50 352/352 [==============================] - 8s 22ms/step - loss: 2.6375 - acc: 0.3256 - top5-acc: 0.6427 - val_loss: 2.6078 - val_acc: 0.3278 - val_top5-acc: 0.6434 Epoch 12/50 352/352 [==============================] - 8s 22ms/step - loss: 2.5573 - acc: 0.3424 - top5-acc: 0.6576 - val_loss: 2.5617 - val_acc: 0.3438 - val_top5-acc: 0.6534 Epoch 13/50 352/352 [==============================] - 8s 22ms/step - loss: 2.5259 - acc: 0.3488 - top5-acc: 0.6640 - val_loss: 2.5177 - val_acc: 0.3550 - val_top5-acc: 0.6652 Epoch 14/50 352/352 [==============================] - 8s 22ms/step - loss: 2.4782 - acc: 0.3586 - top5-acc: 0.6739 - val_loss: 2.5113 - val_acc: 0.3558 - val_top5-acc: 0.6718 Epoch 15/50 352/352 [==============================] - 8s 22ms/step - loss: 2.4242 - acc: 0.3712 - top5-acc: 0.6897 - val_loss: 2.4280 - val_acc: 0.3724 - val_top5-acc: 0.6880 Epoch 16/50 352/352 [==============================] - 8s 22ms/step - loss: 2.3884 - acc: 0.3741 - top5-acc: 0.6967 - val_loss: 2.4670 - val_acc: 0.3654 - val_top5-acc: 0.6794 Epoch 17/50 352/352 [==============================] - 8s 22ms/step - loss: 2.3619 - acc: 0.3797 - top5-acc: 0.7001 - val_loss: 2.3941 - val_acc: 0.3752 - val_top5-acc: 0.6922 Epoch 18/50 352/352 [==============================] - 8s 22ms/step - loss: 2.3183 - acc: 0.3931 - top5-acc: 0.7137 - val_loss: 2.4028 - val_acc: 0.3814 - val_top5-acc: 0.6954 Epoch 19/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2919 - acc: 0.3955 - top5-acc: 0.7209 - val_loss: 2.3672 - val_acc: 0.3878 - val_top5-acc: 0.7022 Epoch 20/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2612 - acc: 0.4038 - top5-acc: 0.7224 - val_loss: 2.3529 - val_acc: 0.3954 - val_top5-acc: 0.6934 Epoch 21/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2416 - acc: 0.4068 - top5-acc: 0.7262 - val_loss: 2.3014 - val_acc: 0.3980 - val_top5-acc: 0.7158 Epoch 22/50 352/352 [==============================] - 8s 22ms/step - loss: 2.2087 - acc: 0.4162 - top5-acc: 0.7359 - val_loss: 2.2904 - val_acc: 0.4062 - val_top5-acc: 0.7120 Epoch 23/50 352/352 [==============================] - 8s 22ms/step - loss: 2.1803 - acc: 0.4200 - top5-acc: 0.7442 - val_loss: 2.3181 - val_acc: 0.4096 - val_top5-acc: 0.7120 Epoch 24/50 352/352 [==============================] - 8s 22ms/step - loss: 2.1718 - acc: 0.4246 - top5-acc: 0.7403 - val_loss: 2.2687 - val_acc: 0.4094 - val_top5-acc: 0.7234 Epoch 25/50 352/352 [==============================] - 8s 22ms/step - loss: 2.1559 - acc: 0.4198 - top5-acc: 0.7458 - val_loss: 2.2730 - val_acc: 0.4060 - val_top5-acc: 0.7190 Epoch 26/50 352/352 [==============================] - 8s 22ms/step - loss: 2.1285 - acc: 0.4300 - top5-acc: 0.7495 - val_loss: 2.2566 - val_acc: 0.4082 - val_top5-acc: 0.7306 Epoch 27/50 352/352 [==============================] - 8s 22ms/step - loss: 2.1118 - acc: 0.4386 - top5-acc: 0.7538 - val_loss: 2.2544 - val_acc: 0.4178 - val_top5-acc: 0.7218 Epoch 28/50 352/352 [==============================] - 8s 22ms/step - loss: 2.1007 - acc: 0.4408 - top5-acc: 0.7562 - val_loss: 2.2703 - val_acc: 0.4136 - val_top5-acc: 0.7172 Epoch 29/50 352/352 [==============================] - 8s 22ms/step - loss: 2.0707 - acc: 0.4446 - top5-acc: 0.7634 - val_loss: 2.2244 - val_acc: 0.4168 - val_top5-acc: 0.7332 Epoch 30/50 352/352 [==============================] - 8s 22ms/step - loss: 2.0694 - acc: 0.4428 - top5-acc: 0.7611 - val_loss: 2.2557 - val_acc: 0.4060 - val_top5-acc: 0.7270 Epoch 31/50 352/352 [==============================] - 8s 22ms/step - loss: 2.0485 - acc: 0.4502 - top5-acc: 0.7672 - val_loss: 2.2192 - val_acc: 0.4214 - val_top5-acc: 0.7308 Epoch 32/50 352/352 [==============================] - 8s 22ms/step - loss: 2.0105 - acc: 0.4617 - top5-acc: 0.7718 - val_loss: 2.2065 - val_acc: 0.4222 - val_top5-acc: 0.7286 Epoch 33/50 352/352 [==============================] - 8s 22ms/step - loss: 2.0238 - acc: 0.4556 - top5-acc: 0.7734 - val_loss: 2.1736 - val_acc: 0.4270 - val_top5-acc: 0.7368 Epoch 34/50 352/352 [==============================] - 8s 22ms/step - loss: 2.0253 - acc: 0.4547 - top5-acc: 0.7712 - val_loss: 2.2231 - val_acc: 0.4280 - val_top5-acc: 0.7308 Epoch 35/50 352/352 [==============================] - 8s 22ms/step - loss: 1.9992 - acc: 0.4593 - top5-acc: 0.7765 - val_loss: 2.1994 - val_acc: 0.4212 - val_top5-acc: 0.7358 Epoch 36/50 352/352 [==============================] - 8s 22ms/step - loss: 1.9849 - acc: 0.4636 - top5-acc: 0.7754 - val_loss: 2.2167 - val_acc: 0.4276 - val_top5-acc: 0.7308 Epoch 37/50 352/352 [==============================] - 8s 22ms/step - loss: 1.9880 - acc: 0.4677 - top5-acc: 0.7783 - val_loss: 2.1746 - val_acc: 0.4270 - val_top5-acc: 0.7416 Epoch 38/50 352/352 [==============================] - 8s 22ms/step - loss: 1.9562 - acc: 0.4720 - top5-acc: 0.7845 - val_loss: 2.1976 - val_acc: 0.4312 - val_top5-acc: 0.7356 Epoch 39/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8736 - acc: 0.4924 - top5-acc: 0.8004 - val_loss: 2.0755 - val_acc: 0.4578 - val_top5-acc: 0.7586 Epoch 40/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8189 - acc: 0.5042 - top5-acc: 0.8076 - val_loss: 2.0804 - val_acc: 0.4508 - val_top5-acc: 0.7600 Epoch 41/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8069 - acc: 0.5062 - top5-acc: 0.8132 - val_loss: 2.0784 - val_acc: 0.4456 - val_top5-acc: 0.7578 Epoch 42/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8156 - acc: 0.5052 - top5-acc: 0.8110 - val_loss: 2.0910 - val_acc: 0.4544 - val_top5-acc: 0.7542 Epoch 43/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8143 - acc: 0.5046 - top5-acc: 0.8105 - val_loss: 2.1037 - val_acc: 0.4466 - val_top5-acc: 0.7562 Epoch 44/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8119 - acc: 0.5032 - top5-acc: 0.8141 - val_loss: 2.0794 - val_acc: 0.4622 - val_top5-acc: 0.7532 Epoch 45/50 352/352 [==============================] - 8s 22ms/step - loss: 1.7611 - acc: 0.5188 - top5-acc: 0.8224 - val_loss: 2.0371 - val_acc: 0.4650 - val_top5-acc: 0.7628 Epoch 46/50 352/352 [==============================] - 8s 22ms/step - loss: 1.7713 - acc: 0.5189 - top5-acc: 0.8226 - val_loss: 2.0245 - val_acc: 0.4630 - val_top5-acc: 0.7644 Epoch 47/50 352/352 [==============================] - 8s 22ms/step - loss: 1.7809 - acc: 0.5130 - top5-acc: 0.8215 - val_loss: 2.0471 - val_acc: 0.4618 - val_top5-acc: 0.7618 Epoch 48/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8052 - acc: 0.5112 - top5-acc: 0.8165 - val_loss: 2.0441 - val_acc: 0.4596 - val_top5-acc: 0.7658 Epoch 49/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8128 - acc: 0.5039 - top5-acc: 0.8178 - val_loss: 2.0569 - val_acc: 0.4600 - val_top5-acc: 0.7614 Epoch 50/50 352/352 [==============================] - 8s 22ms/step - loss: 1.8179 - acc: 0.5089 - top5-acc: 0.8155 - val_loss: 2.0514 - val_acc: 0.4576 - val_top5-acc: 0.7566 313/313 [==============================] - 2s 6ms/step - loss: 2.0142 - acc: 0.4663 - top5-acc: 0.7647 Test accuracy: 46.63% Test top 5 accuracy: 76.47% As shown in the FNet paper, better results can be achieved by increasing the embedding dimensions, increasing the number of FNet blocks, and training the model for longer. You may also try to increase the size of the input images and use different patch sizes. The FNet scales very efficiently to long inputs, runs much faster than attention-based Transformer models, and produces competitive accuracy results. The gMLP model The gMLP is a MLP architecture that features a Spatial Gating Unit (SGU). The SGU enables cross-patch interactions across the spatial (channel) dimension, by: Transforming the input spatially by applying linear projection across patches (along channels). Applying element-wise multiplication of the input and its spatial transformation. Implement the gMLP module class gMLPLayer(layers.Layer): def __init__(self, num_patches, embedding_dim, dropout_rate, *args, **kwargs): super(gMLPLayer, self).__init__(*args, **kwargs) self.channel_projection1 = keras.Sequential( [ layers.Dense(units=embedding_dim * 2), tfa.layers.GELU(), layers.Dropout(rate=dropout_rate), ] ) self.channel_projection2 = layers.Dense(units=embedding_dim) self.spatial_projection = layers.Dense( units=num_patches, bias_initializer=\"Ones\" ) self.normalize1 = layers.LayerNormalization(epsilon=1e-6) self.normalize2 = layers.LayerNormalization(epsilon=1e-6) def spatial_gating_unit(self, x): # Split x along the channel dimensions. # Tensors u and v will in th shape of [batch_size, num_patchs, embedding_dim]. u, v = tf.split(x, num_or_size_splits=2, axis=2) # Apply layer normalization. v = self.normalize2(v) # Apply spatial projection. v_channels = tf.linalg.matrix_transpose(v) v_projected = self.spatial_projection(v_channels) v_projected = tf.linalg.matrix_transpose(v_projected) # Apply element-wise multiplication. return u * v_projected def call(self, inputs): # Apply layer normalization. x = self.normalize1(inputs) # Apply the first channel projection. x_projected shape: [batch_size, num_patches, embedding_dim * 2]. x_projected = self.channel_projection1(x) # Apply the spatial gating unit. x_spatial shape: [batch_size, num_patches, embedding_dim]. x_spatial = self.spatial_gating_unit(x_projected) # Apply the second channel projection. x_projected shape: [batch_size, num_patches, embedding_dim]. x_projected = self.channel_projection2(x_spatial) # Add skip connection. return x + x_projected Build, train, and evaluate the gMLP model Note that training the model with the current settings on a V100 GPUs takes around 9 seconds per epoch. gmlp_blocks = keras.Sequential( [gMLPLayer(num_patches, embedding_dim, dropout_rate) for _ in range(num_blocks)] ) learning_rate = 0.003 gmlp_classifier = build_classifier(gmlp_blocks) history = run_experiment(gmlp_classifier) Epoch 1/50 352/352 [==============================] - 13s 28ms/step - loss: 4.1713 - acc: 0.0704 - top5-acc: 0.2206 - val_loss: 3.5629 - val_acc: 0.1548 - val_top5-acc: 0.4086 Epoch 2/50 352/352 [==============================] - 9s 27ms/step - loss: 3.5146 - acc: 0.1633 - top5-acc: 0.4172 - val_loss: 3.2899 - val_acc: 0.2066 - val_top5-acc: 0.4900 Epoch 3/50 352/352 [==============================] - 9s 26ms/step - loss: 3.2588 - acc: 0.2017 - top5-acc: 0.4895 - val_loss: 3.1152 - val_acc: 0.2362 - val_top5-acc: 0.5278 Epoch 4/50 352/352 [==============================] - 9s 26ms/step - loss: 3.1037 - acc: 0.2331 - top5-acc: 0.5288 - val_loss: 2.9771 - val_acc: 0.2624 - val_top5-acc: 0.5646 Epoch 5/50 352/352 [==============================] - 9s 26ms/step - loss: 2.9483 - acc: 0.2637 - top5-acc: 0.5680 - val_loss: 2.8807 - val_acc: 0.2784 - val_top5-acc: 0.5840 Epoch 6/50 352/352 [==============================] - 9s 26ms/step - loss: 2.8411 - acc: 0.2821 - top5-acc: 0.5930 - val_loss: 2.7246 - val_acc: 0.3146 - val_top5-acc: 0.6256 Epoch 7/50 352/352 [==============================] - 9s 26ms/step - loss: 2.7221 - acc: 0.3085 - top5-acc: 0.6193 - val_loss: 2.7022 - val_acc: 0.3108 - val_top5-acc: 0.6270 Epoch 8/50 352/352 [==============================] - 9s 26ms/step - loss: 2.6296 - acc: 0.3334 - top5-acc: 0.6420 - val_loss: 2.6289 - val_acc: 0.3324 - val_top5-acc: 0.6494 Epoch 9/50 352/352 [==============================] - 9s 26ms/step - loss: 2.5691 - acc: 0.3413 - top5-acc: 0.6563 - val_loss: 2.5353 - val_acc: 0.3586 - val_top5-acc: 0.6746 Epoch 10/50 352/352 [==============================] - 9s 26ms/step - loss: 2.4854 - acc: 0.3575 - top5-acc: 0.6760 - val_loss: 2.5271 - val_acc: 0.3578 - val_top5-acc: 0.6720 Epoch 11/50 352/352 [==============================] - 9s 26ms/step - loss: 2.4252 - acc: 0.3722 - top5-acc: 0.6870 - val_loss: 2.4553 - val_acc: 0.3684 - val_top5-acc: 0.6850 Epoch 12/50 352/352 [==============================] - 9s 26ms/step - loss: 2.3814 - acc: 0.3822 - top5-acc: 0.6985 - val_loss: 2.3841 - val_acc: 0.3888 - val_top5-acc: 0.6966 Epoch 13/50 352/352 [==============================] - 9s 26ms/step - loss: 2.3119 - acc: 0.3950 - top5-acc: 0.7135 - val_loss: 2.4306 - val_acc: 0.3780 - val_top5-acc: 0.6894 Epoch 14/50 352/352 [==============================] - 9s 26ms/step - loss: 2.2886 - acc: 0.4033 - top5-acc: 0.7168 - val_loss: 2.4053 - val_acc: 0.3932 - val_top5-acc: 0.7010 Epoch 15/50 352/352 [==============================] - 9s 26ms/step - loss: 2.2455 - acc: 0.4080 - top5-acc: 0.7233 - val_loss: 2.3443 - val_acc: 0.4004 - val_top5-acc: 0.7128 Epoch 16/50 352/352 [==============================] - 9s 26ms/step - loss: 2.2128 - acc: 0.4152 - top5-acc: 0.7317 - val_loss: 2.3150 - val_acc: 0.4018 - val_top5-acc: 0.7174 Epoch 17/50 352/352 [==============================] - 9s 26ms/step - loss: 2.1990 - acc: 0.4206 - top5-acc: 0.7357 - val_loss: 2.3590 - val_acc: 0.3978 - val_top5-acc: 0.7086 Epoch 18/50 352/352 [==============================] - 9s 26ms/step - loss: 2.1574 - acc: 0.4258 - top5-acc: 0.7451 - val_loss: 2.3140 - val_acc: 0.4052 - val_top5-acc: 0.7256 Epoch 19/50 352/352 [==============================] - 9s 26ms/step - loss: 2.1369 - acc: 0.4309 - top5-acc: 0.7487 - val_loss: 2.3012 - val_acc: 0.4124 - val_top5-acc: 0.7190 Epoch 20/50 352/352 [==============================] - 9s 26ms/step - loss: 2.1222 - acc: 0.4350 - top5-acc: 0.7494 - val_loss: 2.3294 - val_acc: 0.4076 - val_top5-acc: 0.7186 Epoch 21/50 352/352 [==============================] - 9s 26ms/step - loss: 2.0822 - acc: 0.4436 - top5-acc: 0.7576 - val_loss: 2.2498 - val_acc: 0.4302 - val_top5-acc: 0.7276 Epoch 22/50 352/352 [==============================] - 9s 26ms/step - loss: 2.0609 - acc: 0.4518 - top5-acc: 0.7610 - val_loss: 2.2915 - val_acc: 0.4232 - val_top5-acc: 0.7280 Epoch 23/50 352/352 [==============================] - 9s 26ms/step - loss: 2.0482 - acc: 0.4590 - top5-acc: 0.7648 - val_loss: 2.2448 - val_acc: 0.4242 - val_top5-acc: 0.7296 Epoch 24/50 352/352 [==============================] - 9s 26ms/step - loss: 2.0292 - acc: 0.4560 - top5-acc: 0.7705 - val_loss: 2.2526 - val_acc: 0.4334 - val_top5-acc: 0.7324 Epoch 25/50 352/352 [==============================] - 9s 26ms/step - loss: 2.0316 - acc: 0.4544 - top5-acc: 0.7687 - val_loss: 2.2430 - val_acc: 0.4318 - val_top5-acc: 0.7338 Epoch 26/50 352/352 [==============================] - 9s 26ms/step - loss: 1.9988 - acc: 0.4616 - top5-acc: 0.7748 - val_loss: 2.2053 - val_acc: 0.4470 - val_top5-acc: 0.7366 Epoch 27/50 352/352 [==============================] - 9s 26ms/step - loss: 1.9788 - acc: 0.4646 - top5-acc: 0.7806 - val_loss: 2.2313 - val_acc: 0.4378 - val_top5-acc: 0.7420 Epoch 28/50 352/352 [==============================] - 9s 26ms/step - loss: 1.9702 - acc: 0.4688 - top5-acc: 0.7829 - val_loss: 2.2392 - val_acc: 0.4344 - val_top5-acc: 0.7338 Epoch 29/50 352/352 [==============================] - 9s 26ms/step - loss: 1.9488 - acc: 0.4699 - top5-acc: 0.7866 - val_loss: 2.1600 - val_acc: 0.4490 - val_top5-acc: 0.7446 Epoch 30/50 352/352 [==============================] - 9s 26ms/step - loss: 1.9302 - acc: 0.4803 - top5-acc: 0.7878 - val_loss: 2.2069 - val_acc: 0.4410 - val_top5-acc: 0.7486 Epoch 31/50 352/352 [==============================] - 9s 26ms/step - loss: 1.9135 - acc: 0.4806 - top5-acc: 0.7916 - val_loss: 2.1929 - val_acc: 0.4486 - val_top5-acc: 0.7514 Epoch 32/50 352/352 [==============================] - 9s 26ms/step - loss: 1.8890 - acc: 0.4844 - top5-acc: 0.7961 - val_loss: 2.2176 - val_acc: 0.4404 - val_top5-acc: 0.7494 Epoch 33/50 352/352 [==============================] - 9s 26ms/step - loss: 1.8844 - acc: 0.4872 - top5-acc: 0.7980 - val_loss: 2.2321 - val_acc: 0.4444 - val_top5-acc: 0.7460 Epoch 34/50 352/352 [==============================] - 9s 26ms/step - loss: 1.8588 - acc: 0.4912 - top5-acc: 0.8005 - val_loss: 2.1895 - val_acc: 0.4532 - val_top5-acc: 0.7510 Epoch 35/50 352/352 [==============================] - 9s 26ms/step - loss: 1.7259 - acc: 0.5232 - top5-acc: 0.8266 - val_loss: 2.1024 - val_acc: 0.4800 - val_top5-acc: 0.7726 Epoch 36/50 352/352 [==============================] - 9s 26ms/step - loss: 1.6262 - acc: 0.5488 - top5-acc: 0.8437 - val_loss: 2.0712 - val_acc: 0.4830 - val_top5-acc: 0.7754 Epoch 37/50 352/352 [==============================] - 9s 26ms/step - loss: 1.6164 - acc: 0.5481 - top5-acc: 0.8390 - val_loss: 2.1219 - val_acc: 0.4772 - val_top5-acc: 0.7678 Epoch 38/50 352/352 [==============================] - 9s 26ms/step - loss: 1.5850 - acc: 0.5568 - top5-acc: 0.8510 - val_loss: 2.0931 - val_acc: 0.4892 - val_top5-acc: 0.7732 Epoch 39/50 352/352 [==============================] - 9s 26ms/step - loss: 1.5741 - acc: 0.5589 - top5-acc: 0.8507 - val_loss: 2.0910 - val_acc: 0.4910 - val_top5-acc: 0.7700 Epoch 40/50 352/352 [==============================] - 9s 26ms/step - loss: 1.5546 - acc: 0.5675 - top5-acc: 0.8519 - val_loss: 2.1388 - val_acc: 0.4790 - val_top5-acc: 0.7742 Epoch 41/50 352/352 [==============================] - 9s 26ms/step - loss: 1.5464 - acc: 0.5684 - top5-acc: 0.8561 - val_loss: 2.1121 - val_acc: 0.4786 - val_top5-acc: 0.7718 Epoch 42/50 352/352 [==============================] - 9s 26ms/step - loss: 1.4494 - acc: 0.5890 - top5-acc: 0.8702 - val_loss: 2.1157 - val_acc: 0.4944 - val_top5-acc: 0.7802 Epoch 43/50 352/352 [==============================] - 9s 26ms/step - loss: 1.3847 - acc: 0.6069 - top5-acc: 0.8825 - val_loss: 2.1048 - val_acc: 0.4884 - val_top5-acc: 0.7752 Epoch 44/50 352/352 [==============================] - 9s 26ms/step - loss: 1.3724 - acc: 0.6087 - top5-acc: 0.8832 - val_loss: 2.0681 - val_acc: 0.4924 - val_top5-acc: 0.7868 Epoch 45/50 352/352 [==============================] - 9s 26ms/step - loss: 1.3643 - acc: 0.6116 - top5-acc: 0.8840 - val_loss: 2.0965 - val_acc: 0.4932 - val_top5-acc: 0.7752 Epoch 46/50 352/352 [==============================] - 9s 26ms/step - loss: 1.3517 - acc: 0.6184 - top5-acc: 0.8849 - val_loss: 2.0869 - val_acc: 0.4956 - val_top5-acc: 0.7778 Epoch 47/50 352/352 [==============================] - 9s 26ms/step - loss: 1.3377 - acc: 0.6211 - top5-acc: 0.8891 - val_loss: 2.1120 - val_acc: 0.4882 - val_top5-acc: 0.7764 Epoch 48/50 352/352 [==============================] - 9s 26ms/step - loss: 1.3369 - acc: 0.6186 - top5-acc: 0.8888 - val_loss: 2.1257 - val_acc: 0.4912 - val_top5-acc: 0.7752 Epoch 49/50 352/352 [==============================] - 9s 26ms/step - loss: 1.3266 - acc: 0.6190 - top5-acc: 0.8893 - val_loss: 2.0961 - val_acc: 0.4958 - val_top5-acc: 0.7828 Epoch 50/50 352/352 [==============================] - 9s 26ms/step - loss: 1.2731 - acc: 0.6352 - top5-acc: 0.8976 - val_loss: 2.0897 - val_acc: 0.4982 - val_top5-acc: 0.7788 313/313 [==============================] - 2s 7ms/step - loss: 2.0743 - acc: 0.5064 - top5-acc: 0.7828 Test accuracy: 50.64% Test top 5 accuracy: 78.28% As shown in the gMLP paper, better results can be achieved by increasing the embedding dimensions, increasing the number of gMLP blocks, and training the model for longer. You may also try to increase the size of the input images and use different patch sizes. Note that, the paper used advanced regularization strategies, such as MixUp and CutMix, as well as AutoAugment. Implementing the Perceiver model for image classification. Introduction This example implements the Perceiver: General Perception with Iterative Attention model by Andrew Jaegle et al. for image classification, and demonstrates it on the CIFAR-100 dataset. The Perceiver model leverages an asymmetric attention mechanism to iteratively distill inputs into a tight latent bottleneck, allowing it to scale to handle very large inputs. In other words: let's assume that your input data array (e.g. image) has M elements (i.e. patches), where M is large. In a standard Transformer model, a self-attention operation is performed for the M elements. The complexity of this operation is O(M^2). However, the Perceiver model creates a latent array of size N elements, where N << M, and performs two operations iteratively: Cross-attention Transformer between the latent array and the data array - The complexity of this operation is O(M.N). Self-attention Transformer on the latent array - The complexity of this operation is O(N^2). This example requires TensorFlow 2.4 or higher, as well as TensorFlow Addons, which can be installed using the following command: pip install -U tensorflow-addons Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_addons as tfa Prepare the data num_classes = 100 input_shape = (32, 32, 3) (x_train, y_train), (x_test, y_test) = keras.datasets.cifar100.load_data() print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\") print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\") x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 1) x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 1) Configure the hyperparameters learning_rate = 0.001 weight_decay = 0.0001 batch_size = 64 num_epochs = 50 dropout_rate = 0.2 image_size = 64 # We'll resize input images to this size. patch_size = 2 # Size of the patches to be extract from the input images. num_patches = (image_size // patch_size) ** 2 # Size of the data array. latent_dim = 256 # Size of the latent array. projection_dim = 256 # Embedding size of each element in the data and latent arrays. num_heads = 8 # Number of Transformer heads. ffn_units = [ projection_dim, projection_dim, ] # Size of the Transformer Feedforward network. num_transformer_blocks = 4 num_iterations = 2 # Repetitions of the cross-attention and Transformer modules. classifier_units = [ projection_dim, num_classes, ] # Size of the Feedforward network of the final classifier. print(f\"Image size: {image_size} X {image_size} = {image_size ** 2}\") print(f\"Patch size: {patch_size} X {patch_size} = {patch_size ** 2} \") print(f\"Patches per image: {num_patches}\") print(f\"Elements per patch (3 channels): {(patch_size ** 2) * 3}\") print(f\"Latent array shape: {latent_dim} X {projection_dim}\") print(f\"Data array shape: {num_patches} X {projection_dim}\") Image size: 64 X 64 = 4096 Patch size: 2 X 2 = 4 Patches per image: 1024 Elements per patch (3 channels): 12 Latent array shape: 256 X 256 Data array shape: 1024 X 256 Note that, in order to use each pixel as an individual input in the data array, set patch_size to 1. Use data augmentation data_augmentation = keras.Sequential( [ layers.Normalization(), layers.Resizing(image_size, image_size), layers.RandomFlip(\"horizontal\"), layers.RandomZoom( height_factor=0.2, width_factor=0.2 ), ], name=\"data_augmentation\", ) # Compute the mean and the variance of the training data for normalization. data_augmentation.layers[0].adapt(x_train) Implement Feedforward network (FFN) def create_ffn(hidden_units, dropout_rate): ffn_layers = [] for units in hidden_units[:-1]: ffn_layers.append(layers.Dense(units, activation=tf.nn.gelu)) ffn_layers.append(layers.Dense(units=hidden_units[-1])) ffn_layers.append(layers.Dropout(dropout_rate)) ffn = keras.Sequential(ffn_layers) return ffn Implement patch creation as a layer class Patches(layers.Layer): def __init__(self, patch_size): super(Patches, self).__init__() self.patch_size = patch_size def call(self, images): batch_size = tf.shape(images)[0] patches = tf.image.extract_patches( images=images, sizes=[1, self.patch_size, self.patch_size, 1], strides=[1, self.patch_size, self.patch_size, 1], rates=[1, 1, 1, 1], padding=\"VALID\", ) patch_dims = patches.shape[-1] patches = tf.reshape(patches, [batch_size, -1, patch_dims]) return patches Implement the patch encoding layer The PatchEncoder layer will linearly transform a patch by projecting it into a vector of size latent_dim. In addition, it adds a learnable position embedding to the projected vector. Note that the orginal Perceiver paper uses the Fourier feature positional encodings. class PatchEncoder(layers.Layer): def __init__(self, num_patches, projection_dim): super(PatchEncoder, self).__init__() self.num_patches = num_patches self.projection = layers.Dense(units=projection_dim) self.position_embedding = layers.Embedding( input_dim=num_patches, output_dim=projection_dim ) def call(self, patches): positions = tf.range(start=0, limit=self.num_patches, delta=1) encoded = self.projection(patches) + self.position_embedding(positions) return encoded Build the Perceiver model The Perceiver consists of two modules: a cross-attention module and a standard Transformer with self-attention. Cross-attention module The cross-attention expects a (latent_dim, projection_dim) latent array, and the (data_dim, projection_dim) data array as inputs, to produce a (latent_dim, projection_dim) latent array as an output. To apply cross-attention, the query vectors are generated from the latent array, while the key and value vectors are generated from the encoded image. Note that the data array in this example is the image, where the data_dim is set to the num_patches. def create_cross_attention_module( latent_dim, data_dim, projection_dim, ffn_units, dropout_rate ): inputs = { # Recieve the latent array as an input of shape [1, latent_dim, projection_dim]. \"latent_array\": layers.Input(shape=(latent_dim, projection_dim)), # Recieve the data_array (encoded image) as an input of shape [batch_size, data_dim, projection_dim]. \"data_array\": layers.Input(shape=(data_dim, projection_dim)), } # Apply layer norm to the inputs latent_array = layers.LayerNormalization(epsilon=1e-6)(inputs[\"latent_array\"]) data_array = layers.LayerNormalization(epsilon=1e-6)(inputs[\"data_array\"]) # Create query tensor: [1, latent_dim, projection_dim]. query = layers.Dense(units=projection_dim)(latent_array) # Create key tensor: [batch_size, data_dim, projection_dim]. key = layers.Dense(units=projection_dim)(data_array) # Create value tensor: [batch_size, data_dim, projection_dim]. value = layers.Dense(units=projection_dim)(data_array) # Generate cross-attention outputs: [batch_size, latent_dim, projection_dim]. attention_output = layers.Attention(use_scale=True, dropout=0.1)( [query, key, value], return_attention_scores=False ) # Skip connection 1. attention_output = layers.Add()([attention_output, latent_array]) # Apply layer norm. attention_output = layers.LayerNormalization(epsilon=1e-6)(attention_output) # Apply Feedforward network. ffn = create_ffn(hidden_units=ffn_units, dropout_rate=dropout_rate) outputs = ffn(attention_output) # Skip connection 2. outputs = layers.Add()([outputs, attention_output]) # Create the Keras model. model = keras.Model(inputs=inputs, outputs=outputs) return model Transformer module The Transformer expects the output latent vector from the cross-attention module as an input, applies multi-head self-attention to its latent_dim elements, followed by feedforward network, to produce another (latent_dim, projection_dim) latent array. def create_transformer_module( latent_dim, projection_dim, num_heads, num_transformer_blocks, ffn_units, dropout_rate, ): # input_shape: [1, latent_dim, projection_dim] inputs = layers.Input(shape=(latent_dim, projection_dim)) x0 = inputs # Create multiple layers of the Transformer block. for _ in range(num_transformer_blocks): # Apply layer normalization 1. x1 = layers.LayerNormalization(epsilon=1e-6)(x0) # Create a multi-head self-attention layer. attention_output = layers.MultiHeadAttention( num_heads=num_heads, key_dim=projection_dim, dropout=0.1 )(x1, x1) # Skip connection 1. x2 = layers.Add()([attention_output, x0]) # Apply layer normalization 2. x3 = layers.LayerNormalization(epsilon=1e-6)(x2) # Apply Feedforward network. ffn = create_ffn(hidden_units=ffn_units, dropout_rate=dropout_rate) x3 = ffn(x3) # Skip connection 2. x0 = layers.Add()([x3, x2]) # Create the Keras model. model = keras.Model(inputs=inputs, outputs=x0) return model Perceiver model The Perceiver model repeats the cross-attention and Transformer modules num_iterations times—with shared weights and skip connections—to allow the latent array to iteratively extract information from the input image as it is needed. class Perceiver(keras.Model): def __init__( self, patch_size, data_dim, latent_dim, projection_dim, num_heads, num_transformer_blocks, ffn_units, dropout_rate, num_iterations, classifier_units, ): super(Perceiver, self).__init__() self.latent_dim = latent_dim self.data_dim = data_dim self.patch_size = patch_size self.projection_dim = projection_dim self.num_heads = num_heads self.num_transformer_blocks = num_transformer_blocks self.ffn_units = ffn_units self.dropout_rate = dropout_rate self.num_iterations = num_iterations self.classifier_units = classifier_units def build(self, input_shape): # Create latent array. self.latent_array = self.add_weight( shape=(self.latent_dim, self.projection_dim), initializer=\"random_normal\", trainable=True, ) # Create patching module. self.patcher = Patches(self.patch_size) # Create patch encoder. self.patch_encoder = PatchEncoder(self.data_dim, self.projection_dim) # Create cross-attenion module. self.cross_attention = create_cross_attention_module( self.latent_dim, self.data_dim, self.projection_dim, self.ffn_units, self.dropout_rate, ) # Create Transformer module. self.transformer = create_transformer_module( self.latent_dim, self.projection_dim, self.num_heads, self.num_transformer_blocks, self.ffn_units, self.dropout_rate, ) # Create global average pooling layer. self.global_average_pooling = layers.GlobalAveragePooling1D() # Create a classification head. self.classification_head = create_ffn( hidden_units=self.classifier_units, dropout_rate=self.dropout_rate ) super(Perceiver, self).build(input_shape) def call(self, inputs): # Augment data. augmented = data_augmentation(inputs) # Create patches. patches = self.patcher(augmented) # Encode patches. encoded_patches = self.patch_encoder(patches) # Prepare cross-attention inputs. cross_attention_inputs = { \"latent_array\": tf.expand_dims(self.latent_array, 0), \"data_array\": encoded_patches, } # Apply the cross-attention and the Transformer modules iteratively. for _ in range(self.num_iterations): # Apply cross-attention from the latent array to the data array. latent_array = self.cross_attention(cross_attention_inputs) # Apply self-attention Transformer to the latent array. latent_array = self.transformer(latent_array) # Set the latent array of the next iteration. cross_attention_inputs[\"latent_array\"] = latent_array # Apply global average pooling to generate a [batch_size, projection_dim] repesentation tensor. representation = self.global_average_pooling(latent_array) # Generate logits. logits = self.classification_head(representation) return logits Compile, train, and evaluate the mode def run_experiment(model): # Create LAMB optimizer with weight decay. optimizer = tfa.optimizers.LAMB( learning_rate=learning_rate, weight_decay_rate=weight_decay, ) # Compile the model. model.compile( optimizer=optimizer, loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[ keras.metrics.SparseCategoricalAccuracy(name=\"acc\"), keras.metrics.SparseTopKCategoricalAccuracy(5, name=\"top5-acc\"), ], ) # Create a learning rate scheduler callback. reduce_lr = keras.callbacks.ReduceLROnPlateau( monitor=\"val_loss\", factor=0.2, patience=3 ) # Create an early stopping callback. early_stopping = tf.keras.callbacks.EarlyStopping( monitor=\"val_loss\", patience=15, restore_best_weights=True ) # Fit the model. history = model.fit( x=x_train, y=y_train, batch_size=batch_size, epochs=num_epochs, validation_split=0.1, callbacks=[early_stopping, reduce_lr], ) _, accuracy, top_5_accuracy = model.evaluate(x_test, y_test) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") print(f\"Test top 5 accuracy: {round(top_5_accuracy * 100, 2)}%\") # Return history to plot learning curves. return history Note that training the perceiver model with the current settings on a V100 GPUs takes around 200 seconds. perceiver_classifier = Perceiver( patch_size, num_patches, latent_dim, projection_dim, num_heads, num_transformer_blocks, ffn_units, dropout_rate, num_iterations, classifier_units, ) history = run_experiment(perceiver_classifier) Epoch 1/100 704/704 [==============================] - 305s 405ms/step - loss: 4.4550 - acc: 0.0389 - top5-acc: 0.1407 - val_loss: 4.0544 - val_acc: 0.0802 - val_top5-acc: 0.2516 Epoch 2/100 704/704 [==============================] - 284s 403ms/step - loss: 4.0639 - acc: 0.0889 - top5-acc: 0.2576 - val_loss: 3.7379 - val_acc: 0.1272 - val_top5-acc: 0.3556 Epoch 3/100 704/704 [==============================] - 283s 402ms/step - loss: 3.8400 - acc: 0.1226 - top5-acc: 0.3326 - val_loss: 3.4527 - val_acc: 0.1750 - val_top5-acc: 0.4350 Epoch 4/100 704/704 [==============================] - 283s 402ms/step - loss: 3.5917 - acc: 0.1657 - top5-acc: 0.4063 - val_loss: 3.2160 - val_acc: 0.2176 - val_top5-acc: 0.5048 Epoch 5/100 704/704 [==============================] - 283s 403ms/step - loss: 3.3820 - acc: 0.2082 - top5-acc: 0.4638 - val_loss: 2.9947 - val_acc: 0.2584 - val_top5-acc: 0.5732 Epoch 6/100 704/704 [==============================] - 284s 403ms/step - loss: 3.2487 - acc: 0.2338 - top5-acc: 0.4991 - val_loss: 2.9179 - val_acc: 0.2770 - val_top5-acc: 0.5744 Epoch 7/100 704/704 [==============================] - 283s 402ms/step - loss: 3.1228 - acc: 0.2605 - top5-acc: 0.5295 - val_loss: 2.7958 - val_acc: 0.2994 - val_top5-acc: 0.6100 Epoch 8/100 704/704 [==============================] - 283s 402ms/step - loss: 2.9989 - acc: 0.2862 - top5-acc: 0.5588 - val_loss: 2.7117 - val_acc: 0.3208 - val_top5-acc: 0.6340 Epoch 9/100 704/704 [==============================] - 283s 402ms/step - loss: 2.9294 - acc: 0.3018 - top5-acc: 0.5763 - val_loss: 2.5933 - val_acc: 0.3390 - val_top5-acc: 0.6636 Epoch 10/100 704/704 [==============================] - 283s 402ms/step - loss: 2.8687 - acc: 0.3139 - top5-acc: 0.5934 - val_loss: 2.5030 - val_acc: 0.3614 - val_top5-acc: 0.6764 Epoch 11/100 704/704 [==============================] - 283s 402ms/step - loss: 2.7771 - acc: 0.3341 - top5-acc: 0.6098 - val_loss: 2.4657 - val_acc: 0.3704 - val_top5-acc: 0.6928 Epoch 12/100 704/704 [==============================] - 283s 402ms/step - loss: 2.7306 - acc: 0.3436 - top5-acc: 0.6229 - val_loss: 2.4441 - val_acc: 0.3738 - val_top5-acc: 0.6878 Epoch 13/100 704/704 [==============================] - 283s 402ms/step - loss: 2.6863 - acc: 0.3546 - top5-acc: 0.6346 - val_loss: 2.3508 - val_acc: 0.3892 - val_top5-acc: 0.7050 Epoch 14/100 704/704 [==============================] - 283s 402ms/step - loss: 2.6107 - acc: 0.3708 - top5-acc: 0.6537 - val_loss: 2.3219 - val_acc: 0.3996 - val_top5-acc: 0.7108 Epoch 15/100 704/704 [==============================] - 283s 402ms/step - loss: 2.5559 - acc: 0.3836 - top5-acc: 0.6664 - val_loss: 2.2748 - val_acc: 0.4140 - val_top5-acc: 0.7242 Epoch 16/100 704/704 [==============================] - 283s 402ms/step - loss: 2.5016 - acc: 0.3942 - top5-acc: 0.6761 - val_loss: 2.2364 - val_acc: 0.4238 - val_top5-acc: 0.7264 Epoch 17/100 704/704 [==============================] - 283s 402ms/step - loss: 2.4554 - acc: 0.4056 - top5-acc: 0.6897 - val_loss: 2.1684 - val_acc: 0.4418 - val_top5-acc: 0.7452 Epoch 18/100 704/704 [==============================] - 283s 402ms/step - loss: 2.3926 - acc: 0.4209 - top5-acc: 0.7024 - val_loss: 2.1614 - val_acc: 0.4372 - val_top5-acc: 0.7428 Epoch 19/100 704/704 [==============================] - 283s 402ms/step - loss: 2.3617 - acc: 0.4264 - top5-acc: 0.7119 - val_loss: 2.1595 - val_acc: 0.4382 - val_top5-acc: 0.7408 Epoch 20/100 704/704 [==============================] - 283s 402ms/step - loss: 2.3355 - acc: 0.4324 - top5-acc: 0.7133 - val_loss: 2.1187 - val_acc: 0.4462 - val_top5-acc: 0.7490 Epoch 21/100 704/704 [==============================] - 283s 402ms/step - loss: 2.2571 - acc: 0.4512 - top5-acc: 0.7299 - val_loss: 2.1095 - val_acc: 0.4424 - val_top5-acc: 0.7534 Epoch 22/100 704/704 [==============================] - 283s 402ms/step - loss: 2.2374 - acc: 0.4559 - top5-acc: 0.7357 - val_loss: 2.0997 - val_acc: 0.4398 - val_top5-acc: 0.7554 Epoch 23/100 704/704 [==============================] - 283s 402ms/step - loss: 2.2108 - acc: 0.4628 - top5-acc: 0.7452 - val_loss: 2.0662 - val_acc: 0.4574 - val_top5-acc: 0.7598 Epoch 24/100 704/704 [==============================] - 283s 402ms/step - loss: 2.1628 - acc: 0.4728 - top5-acc: 0.7555 - val_loss: 2.0564 - val_acc: 0.4564 - val_top5-acc: 0.7584 Epoch 25/100 704/704 [==============================] - 283s 402ms/step - loss: 2.1169 - acc: 0.4834 - top5-acc: 0.7616 - val_loss: 2.0793 - val_acc: 0.4600 - val_top5-acc: 0.7538 Epoch 26/100 704/704 [==============================] - 283s 402ms/step - loss: 2.0938 - acc: 0.4867 - top5-acc: 0.7743 - val_loss: 2.0835 - val_acc: 0.4566 - val_top5-acc: 0.7506 Epoch 27/100 704/704 [==============================] - 283s 402ms/step - loss: 2.0479 - acc: 0.4993 - top5-acc: 0.7816 - val_loss: 2.0790 - val_acc: 0.4610 - val_top5-acc: 0.7556 Epoch 28/100 704/704 [==============================] - 283s 402ms/step - loss: 1.8480 - acc: 0.5493 - top5-acc: 0.8159 - val_loss: 1.8846 - val_acc: 0.5046 - val_top5-acc: 0.7890 Epoch 29/100 704/704 [==============================] - 283s 402ms/step - loss: 1.7532 - acc: 0.5731 - top5-acc: 0.8362 - val_loss: 1.8844 - val_acc: 0.5106 - val_top5-acc: 0.7976 Epoch 30/100 704/704 [==============================] - 283s 402ms/step - loss: 1.7113 - acc: 0.5827 - top5-acc: 0.8434 - val_loss: 1.8792 - val_acc: 0.5096 - val_top5-acc: 0.7928 Epoch 31/100 704/704 [==============================] - 283s 403ms/step - loss: 1.6831 - acc: 0.5891 - top5-acc: 0.8511 - val_loss: 1.8938 - val_acc: 0.5044 - val_top5-acc: 0.7914 Epoch 32/100 704/704 [==============================] - 284s 403ms/step - loss: 1.6480 - acc: 0.5977 - top5-acc: 0.8562 - val_loss: 1.9055 - val_acc: 0.5034 - val_top5-acc: 0.7922 Epoch 33/100 704/704 [==============================] - 284s 403ms/step - loss: 1.6320 - acc: 0.6015 - top5-acc: 0.8627 - val_loss: 1.9064 - val_acc: 0.5056 - val_top5-acc: 0.7896 Epoch 34/100 704/704 [==============================] - 283s 403ms/step - loss: 1.5821 - acc: 0.6145 - top5-acc: 0.8673 - val_loss: 1.8912 - val_acc: 0.5138 - val_top5-acc: 0.7936 Epoch 35/100 704/704 [==============================] - 283s 403ms/step - loss: 1.5791 - acc: 0.6163 - top5-acc: 0.8719 - val_loss: 1.8963 - val_acc: 0.5090 - val_top5-acc: 0.7982 Epoch 36/100 704/704 [==============================] - 283s 402ms/step - loss: 1.5680 - acc: 0.6178 - top5-acc: 0.8741 - val_loss: 1.8998 - val_acc: 0.5142 - val_top5-acc: 0.7936 Epoch 37/100 704/704 [==============================] - 284s 403ms/step - loss: 1.5506 - acc: 0.6218 - top5-acc: 0.8743 - val_loss: 1.8941 - val_acc: 0.5142 - val_top5-acc: 0.7952 Epoch 38/100 704/704 [==============================] - 283s 402ms/step - loss: 1.5611 - acc: 0.6216 - top5-acc: 0.8722 - val_loss: 1.8946 - val_acc: 0.5183 - val_top5-acc: 0.7956 Epoch 39/100 704/704 [==============================] - 284s 403ms/step - loss: 1.5541 - acc: 0.6215 - top5-acc: 0.8764 - val_loss: 1.8923 - val_acc: 0.5180 - val_top5-acc: 0.7962 Epoch 40/100 704/704 [==============================] - 283s 403ms/step - loss: 1.5505 - acc: 0.6228 - top5-acc: 0.8773 - val_loss: 1.8934 - val_acc: 0.5232 - val_top5-acc: 0.7962 Epoch 41/100 704/704 [==============================] - 283s 402ms/step - loss: 1.5604 - acc: 0.6224 - top5-acc: 0.8747 - val_loss: 1.8938 - val_acc: 0.5230 - val_top5-acc: 0.7958 Epoch 42/100 704/704 [==============================] - 283s 402ms/step - loss: 1.5545 - acc: 0.6194 - top5-acc: 0.8784 - val_loss: 1.8938 - val_acc: 0.5240 - val_top5-acc: 0.7966 Epoch 43/100 704/704 [==============================] - 283s 402ms/step - loss: 1.5630 - acc: 0.6210 - top5-acc: 0.8758 - val_loss: 1.8939 - val_acc: 0.5240 - val_top5-acc: 0.7958 Epoch 44/100 704/704 [==============================] - 283s 402ms/step - loss: 1.5569 - acc: 0.6198 - top5-acc: 0.8756 - val_loss: 1.8938 - val_acc: 0.5240 - val_top5-acc: 0.7060 Epoch 45/100 704/704 [==============================] - 283s 402ms/step - loss: 1.5569 - acc: 0.6197 - top5-acc: 0.8770 - val_loss: 1.8940 - val_acc: 0.5140 - val_top5-acc: 0.7962 313/313 [==============================] - 22s 69ms/step - loss: 1.8630 - acc: 0.5264 - top5-acc: 0.8087 Test accuracy: 52.64% Test top 5 accuracy: 80.87% After 45 epochs, the Perceiver model achieves around 53% accuracy and 81% top-5 accuracy on the test data. As mentioned in the ablations of the Perceiver paper, you can obtain better results by increasing the latent array size, increasing the (projection) dimensions of the latent array and data array elements, increasing the number of blocks in the Transformer module, and increasing the number of iterations of applying the cross-attention and the latent Transformer modules. You may also try to increase the size the input images and use different patch sizes. The Perceiver benefits from inceasing the model size. However, larger models needs bigger accelerators to fit in and train efficiently. This is why in the Perceiver paper they used 32 TPU cores to run the experiments. Image classification using Swin Transformers, a general-purpose backbone for computer vision. This example implements Swin Transformer: Hierarchical Vision Transformer using Shifted Windows by Liu et al. for image classification, and demonstrates it on the CIFAR-100 dataset. Swin Transformer (Shifted Window Transformer) can serve as a general-purpose backbone for computer vision. Swin Transformer is a hierarchical Transformer whose representations are computed with shifted windows. The shifted window scheme brings greater efficiency by limiting self-attention computation to non-overlapping local windows while also allowing for cross-window connections. This architecture has the flexibility to model information at various scales and has a linear computational complexity with respect to image size. This example requires TensorFlow 2.5 or higher, as well as TensorFlow Addons, which can be installed using the following commands: !pip install -U tensorflow-addons Collecting tensorflow-addons Downloading tensorflow_addons-0.14.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)  |████████████████████████████████| 1.1 MB 7.9 MB/s [?25hCollecting typeguard>=2.7 Downloading typeguard-2.12.1-py3-none-any.whl (17 kB) Installing collected packages: typeguard, tensorflow-addons Successfully installed tensorflow-addons-0.14.0 typeguard-2.12.1 Setup import matplotlib.pyplot as plt import numpy as np import tensorflow as tf import tensorflow_addons as tfa from tensorflow import keras from tensorflow.keras import layers Prepare the data We load the CIFAR-100 dataset through tf.keras.datasets, normalize the images, and convert the integer labels to one-hot encoded vectors. num_classes = 100 input_shape = (32, 32, 3) (x_train, y_train), (x_test, y_test) = keras.datasets.cifar100.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\") print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\") plt.figure(figsize=(10, 10)) for i in range(25): plt.subplot(5, 5, i + 1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(x_train[i]) plt.show() Downloading data from https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz 169009152/169001437 [==============================] - 3s 0us/step 169017344/169001437 [==============================] - 3s 0us/step x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 100) x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 100) png Configure the hyperparameters A key parameter to pick is the patch_size, the size of the input patches. In order to use each pixel as an individual input, you can set patch_size to (1, 1). Below, we take inspiration from the original paper settings for training on ImageNet-1K, keeping most of the original settings for this example. patch_size = (2, 2) # 2-by-2 sized patches dropout_rate = 0.03 # Dropout rate num_heads = 8 # Attention heads embed_dim = 64 # Embedding dimension num_mlp = 256 # MLP layer size qkv_bias = True # Convert embedded patches to query, key, and values with a learnable additive value window_size = 2 # Size of attention window shift_size = 1 # Size of shifting window image_dimension = 32 # Initial image size num_patch_x = input_shape[0] // patch_size[0] num_patch_y = input_shape[1] // patch_size[1] learning_rate = 1e-3 batch_size = 128 num_epochs = 40 validation_split = 0.1 weight_decay = 0.0001 label_smoothing = 0.1 Helper functions We create two helper functions to help us get a sequence of patches from the image, merge patches, and apply dropout. def window_partition(x, window_size): _, height, width, channels = x.shape patch_num_y = height // window_size patch_num_x = width // window_size x = tf.reshape( x, shape=(-1, patch_num_y, window_size, patch_num_x, window_size, channels) ) x = tf.transpose(x, (0, 1, 3, 2, 4, 5)) windows = tf.reshape(x, shape=(-1, window_size, window_size, channels)) return windows def window_reverse(windows, window_size, height, width, channels): patch_num_y = height // window_size patch_num_x = width // window_size x = tf.reshape( windows, shape=(-1, patch_num_y, patch_num_x, window_size, window_size, channels), ) x = tf.transpose(x, perm=(0, 1, 3, 2, 4, 5)) x = tf.reshape(x, shape=(-1, height, width, channels)) return x class DropPath(layers.Layer): def __init__(self, drop_prob=None, **kwargs): super(DropPath, self).__init__(**kwargs) self.drop_prob = drop_prob def call(self, x): input_shape = tf.shape(x) batch_size = input_shape[0] rank = x.shape.rank shape = (batch_size,) + (1,) * (rank - 1) random_tensor = (1 - self.drop_prob) + tf.random.uniform(shape, dtype=x.dtype) path_mask = tf.floor(random_tensor) output = tf.math.divide(x, 1 - self.drop_prob) * path_mask return output Window based multi-head self-attention Usually Transformers perform global self-attention, where the relationships between a token and all other tokens are computed. The global computation leads to quadratic complexity with respect to the number of tokens. Here, as the original paper suggests, we compute self-attention within local windows, in a non-overlapping manner. Global self-attention leads to quadratic computational complexity in the number of patches, whereas window-based self-attention leads to linear complexity and is easily scalable. class WindowAttention(layers.Layer): def __init__( self, dim, window_size, num_heads, qkv_bias=True, dropout_rate=0.0, **kwargs ): super(WindowAttention, self).__init__(**kwargs) self.dim = dim self.window_size = window_size self.num_heads = num_heads self.scale = (dim // num_heads) ** -0.5 self.qkv = layers.Dense(dim * 3, use_bias=qkv_bias) self.dropout = layers.Dropout(dropout_rate) self.proj = layers.Dense(dim) def build(self, input_shape): num_window_elements = (2 * self.window_size[0] - 1) * ( 2 * self.window_size[1] - 1 ) self.relative_position_bias_table = self.add_weight( shape=(num_window_elements, self.num_heads), initializer=tf.initializers.Zeros(), trainable=True, ) coords_h = np.arange(self.window_size[0]) coords_w = np.arange(self.window_size[1]) coords_matrix = np.meshgrid(coords_h, coords_w, indexing=\"ij\") coords = np.stack(coords_matrix) coords_flatten = coords.reshape(2, -1) relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] relative_coords = relative_coords.transpose([1, 2, 0]) relative_coords[:, :, 0] += self.window_size[0] - 1 relative_coords[:, :, 1] += self.window_size[1] - 1 relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1 relative_position_index = relative_coords.sum(-1) self.relative_position_index = tf.Variable( initial_value=tf.convert_to_tensor(relative_position_index), trainable=False ) def call(self, x, mask=None): _, size, channels = x.shape head_dim = channels // self.num_heads x_qkv = self.qkv(x) x_qkv = tf.reshape(x_qkv, shape=(-1, size, 3, self.num_heads, head_dim)) x_qkv = tf.transpose(x_qkv, perm=(2, 0, 3, 1, 4)) q, k, v = x_qkv[0], x_qkv[1], x_qkv[2] q = q * self.scale k = tf.transpose(k, perm=(0, 1, 3, 2)) attn = q @ k num_window_elements = self.window_size[0] * self.window_size[1] relative_position_index_flat = tf.reshape( self.relative_position_index, shape=(-1,) ) relative_position_bias = tf.gather( self.relative_position_bias_table, relative_position_index_flat ) relative_position_bias = tf.reshape( relative_position_bias, shape=(num_window_elements, num_window_elements, -1) ) relative_position_bias = tf.transpose(relative_position_bias, perm=(2, 0, 1)) attn = attn + tf.expand_dims(relative_position_bias, axis=0) if mask is not None: nW = mask.get_shape()[0] mask_float = tf.cast( tf.expand_dims(tf.expand_dims(mask, axis=1), axis=0), tf.float32 ) attn = ( tf.reshape(attn, shape=(-1, nW, self.num_heads, size, size)) + mask_float ) attn = tf.reshape(attn, shape=(-1, self.num_heads, size, size)) attn = keras.activations.softmax(attn, axis=-1) else: attn = keras.activations.softmax(attn, axis=-1) attn = self.dropout(attn) x_qkv = attn @ v x_qkv = tf.transpose(x_qkv, perm=(0, 2, 1, 3)) x_qkv = tf.reshape(x_qkv, shape=(-1, size, channels)) x_qkv = self.proj(x_qkv) x_qkv = self.dropout(x_qkv) return x_qkv The complete Swin Transformer model Finally, we put together the complete Swin Transformer by replacing the standard multi-head attention (MHA) with shifted windows attention. As suggested in the original paper, we create a model comprising of a shifted window-based MHA layer, followed by a 2-layer MLP with GELU nonlinearity in between, applying LayerNormalization before each MSA layer and each MLP, and a residual connection after each of these layers. Notice that we only create a simple MLP with 2 Dense and 2 Dropout layers. Often you will see models using ResNet-50 as the MLP which is quite standard in the literature. However in this paper the authors use a 2-layer MLP with GELU nonlinearity in between. class SwinTransformer(layers.Layer): def __init__( self, dim, num_patch, num_heads, window_size=7, shift_size=0, num_mlp=1024, qkv_bias=True, dropout_rate=0.0, **kwargs, ): super(SwinTransformer, self).__init__(**kwargs) self.dim = dim # number of input dimensions self.num_patch = num_patch # number of embedded patches self.num_heads = num_heads # number of attention heads self.window_size = window_size # size of window self.shift_size = shift_size # size of window shift self.num_mlp = num_mlp # number of MLP nodes self.norm1 = layers.LayerNormalization(epsilon=1e-5) self.attn = WindowAttention( dim, window_size=(self.window_size, self.window_size), num_heads=num_heads, qkv_bias=qkv_bias, dropout_rate=dropout_rate, ) self.drop_path = DropPath(dropout_rate) self.norm2 = layers.LayerNormalization(epsilon=1e-5) self.mlp = keras.Sequential( [ layers.Dense(num_mlp), layers.Activation(keras.activations.gelu), layers.Dropout(dropout_rate), layers.Dense(dim), layers.Dropout(dropout_rate), ] ) if min(self.num_patch) < self.window_size: self.shift_size = 0 self.window_size = min(self.num_patch) def build(self, input_shape): if self.shift_size == 0: self.attn_mask = None else: height, width = self.num_patch h_slices = ( slice(0, -self.window_size), slice(-self.window_size, -self.shift_size), slice(-self.shift_size, None), ) w_slices = ( slice(0, -self.window_size), slice(-self.window_size, -self.shift_size), slice(-self.shift_size, None), ) mask_array = np.zeros((1, height, width, 1)) count = 0 for h in h_slices: for w in w_slices: mask_array[:, h, w, :] = count count += 1 mask_array = tf.convert_to_tensor(mask_array) # mask array to windows mask_windows = window_partition(mask_array, self.window_size) mask_windows = tf.reshape( mask_windows, shape=[-1, self.window_size * self.window_size] ) attn_mask = tf.expand_dims(mask_windows, axis=1) - tf.expand_dims( mask_windows, axis=2 ) attn_mask = tf.where(attn_mask != 0, -100.0, attn_mask) attn_mask = tf.where(attn_mask == 0, 0.0, attn_mask) self.attn_mask = tf.Variable(initial_value=attn_mask, trainable=False) def call(self, x): height, width = self.num_patch _, num_patches_before, channels = x.shape x_skip = x x = self.norm1(x) x = tf.reshape(x, shape=(-1, height, width, channels)) if self.shift_size > 0: shifted_x = tf.roll( x, shift=[-self.shift_size, -self.shift_size], axis=[1, 2] ) else: shifted_x = x x_windows = window_partition(shifted_x, self.window_size) x_windows = tf.reshape( x_windows, shape=(-1, self.window_size * self.window_size, channels) ) attn_windows = self.attn(x_windows, mask=self.attn_mask) attn_windows = tf.reshape( attn_windows, shape=(-1, self.window_size, self.window_size, channels) ) shifted_x = window_reverse( attn_windows, self.window_size, height, width, channels ) if self.shift_size > 0: x = tf.roll( shifted_x, shift=[self.shift_size, self.shift_size], axis=[1, 2] ) else: x = shifted_x x = tf.reshape(x, shape=(-1, height * width, channels)) x = self.drop_path(x) x = x_skip + x x_skip = x x = self.norm2(x) x = self.mlp(x) x = self.drop_path(x) x = x_skip + x return x Model training and evaluation Extract and embed patches We first create 3 layers to help us extract, embed and merge patches from the images on top of which we will later use the Swin Transformer class we built. class PatchExtract(layers.Layer): def __init__(self, patch_size, **kwargs): super(PatchExtract, self).__init__(**kwargs) self.patch_size_x = patch_size[0] self.patch_size_y = patch_size[0] def call(self, images): batch_size = tf.shape(images)[0] patches = tf.image.extract_patches( images=images, sizes=(1, self.patch_size_x, self.patch_size_y, 1), strides=(1, self.patch_size_x, self.patch_size_y, 1), rates=(1, 1, 1, 1), padding=\"VALID\", ) patch_dim = patches.shape[-1] patch_num = patches.shape[1] return tf.reshape(patches, (batch_size, patch_num * patch_num, patch_dim)) class PatchEmbedding(layers.Layer): def __init__(self, num_patch, embed_dim, **kwargs): super(PatchEmbedding, self).__init__(**kwargs) self.num_patch = num_patch self.proj = layers.Dense(embed_dim) self.pos_embed = layers.Embedding(input_dim=num_patch, output_dim=embed_dim) def call(self, patch): pos = tf.range(start=0, limit=self.num_patch, delta=1) return self.proj(patch) + self.pos_embed(pos) class PatchMerging(tf.keras.layers.Layer): def __init__(self, num_patch, embed_dim): super(PatchMerging, self).__init__() self.num_patch = num_patch self.embed_dim = embed_dim self.linear_trans = layers.Dense(2 * embed_dim, use_bias=False) def call(self, x): height, width = self.num_patch _, _, C = x.get_shape().as_list() x = tf.reshape(x, shape=(-1, height, width, C)) x0 = x[:, 0::2, 0::2, :] x1 = x[:, 1::2, 0::2, :] x2 = x[:, 0::2, 1::2, :] x3 = x[:, 1::2, 1::2, :] x = tf.concat((x0, x1, x2, x3), axis=-1) x = tf.reshape(x, shape=(-1, (height // 2) * (width // 2), 4 * C)) return self.linear_trans(x) Build the model We put together the Swin Transformer model. input = layers.Input(input_shape) x = layers.RandomCrop(image_dimension, image_dimension)(input) x = layers.RandomFlip(\"horizontal\")(x) x = PatchExtract(patch_size)(x) x = PatchEmbedding(num_patch_x * num_patch_y, embed_dim)(x) x = SwinTransformer( dim=embed_dim, num_patch=(num_patch_x, num_patch_y), num_heads=num_heads, window_size=window_size, shift_size=0, num_mlp=num_mlp, qkv_bias=qkv_bias, dropout_rate=dropout_rate, )(x) x = SwinTransformer( dim=embed_dim, num_patch=(num_patch_x, num_patch_y), num_heads=num_heads, window_size=window_size, shift_size=shift_size, num_mlp=num_mlp, qkv_bias=qkv_bias, dropout_rate=dropout_rate, )(x) x = PatchMerging((num_patch_x, num_patch_y), embed_dim=embed_dim)(x) x = layers.GlobalAveragePooling1D()(x) output = layers.Dense(num_classes, activation=\"softmax\")(x) 2021-09-13 08:03:19.266695: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:19.275199: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:19.275997: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:19.277483: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. 2021-09-13 08:03:19.278433: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:19.279102: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:19.279706: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:21.258771: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:21.259481: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:21.260191: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 08:03:21.261723: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14684 MB memory: -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:04.0, compute capability: 7.0 Train on CIFAR-100 We train the model on CIFAR-100. Here, we only train the model for 40 epochs to keep the training time short in this example. In practice, you should train for 150 epochs to reach convergence. model = keras.Model(input, output) model.compile( loss=keras.losses.CategoricalCrossentropy(label_smoothing=label_smoothing), optimizer=tfa.optimizers.AdamW( learning_rate=learning_rate, weight_decay=weight_decay ), metrics=[ keras.metrics.CategoricalAccuracy(name=\"accuracy\"), keras.metrics.TopKCategoricalAccuracy(5, name=\"top-5-accuracy\"), ], ) history = model.fit( x_train, y_train, batch_size=batch_size, epochs=num_epochs, validation_split=validation_split, ) 2021-09-13 08:03:23.935873: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2) Epoch 1/40 352/352 [==============================] - 19s 34ms/step - loss: 4.1679 - accuracy: 0.0817 - top-5-accuracy: 0.2551 - val_loss: 3.8964 - val_accuracy: 0.1242 - val_top-5-accuracy: 0.3568 Epoch 2/40 352/352 [==============================] - 11s 32ms/step - loss: 3.7278 - accuracy: 0.1617 - top-5-accuracy: 0.4246 - val_loss: 3.6518 - val_accuracy: 0.1756 - val_top-5-accuracy: 0.4580 Epoch 3/40 352/352 [==============================] - 11s 32ms/step - loss: 3.5245 - accuracy: 0.2077 - top-5-accuracy: 0.4946 - val_loss: 3.4609 - val_accuracy: 0.2248 - val_top-5-accuracy: 0.5222 Epoch 4/40 352/352 [==============================] - 11s 32ms/step - loss: 3.3856 - accuracy: 0.2408 - top-5-accuracy: 0.5430 - val_loss: 3.3515 - val_accuracy: 0.2514 - val_top-5-accuracy: 0.5540 Epoch 5/40 352/352 [==============================] - 11s 32ms/step - loss: 3.2772 - accuracy: 0.2697 - top-5-accuracy: 0.5760 - val_loss: 3.3012 - val_accuracy: 0.2712 - val_top-5-accuracy: 0.5758 Epoch 6/40 352/352 [==============================] - 11s 32ms/step - loss: 3.1845 - accuracy: 0.2915 - top-5-accuracy: 0.6071 - val_loss: 3.2104 - val_accuracy: 0.2866 - val_top-5-accuracy: 0.5994 Epoch 7/40 352/352 [==============================] - 11s 32ms/step - loss: 3.1104 - accuracy: 0.3126 - top-5-accuracy: 0.6288 - val_loss: 3.1408 - val_accuracy: 0.3038 - val_top-5-accuracy: 0.6176 Epoch 8/40 352/352 [==============================] - 11s 32ms/step - loss: 3.0616 - accuracy: 0.3268 - top-5-accuracy: 0.6423 - val_loss: 3.0853 - val_accuracy: 0.3138 - val_top-5-accuracy: 0.6408 Epoch 9/40 352/352 [==============================] - 11s 31ms/step - loss: 3.0237 - accuracy: 0.3349 - top-5-accuracy: 0.6541 - val_loss: 3.0882 - val_accuracy: 0.3130 - val_top-5-accuracy: 0.6370 Epoch 10/40 352/352 [==============================] - 11s 31ms/step - loss: 2.9877 - accuracy: 0.3438 - top-5-accuracy: 0.6649 - val_loss: 3.0532 - val_accuracy: 0.3298 - val_top-5-accuracy: 0.6482 Epoch 11/40 352/352 [==============================] - 11s 31ms/step - loss: 2.9571 - accuracy: 0.3520 - top-5-accuracy: 0.6712 - val_loss: 3.0547 - val_accuracy: 0.3320 - val_top-5-accuracy: 0.6450 Epoch 12/40 352/352 [==============================] - 11s 31ms/step - loss: 2.9238 - accuracy: 0.3640 - top-5-accuracy: 0.6798 - val_loss: 2.9833 - val_accuracy: 0.3462 - val_top-5-accuracy: 0.6602 Epoch 13/40 352/352 [==============================] - 11s 31ms/step - loss: 2.9048 - accuracy: 0.3674 - top-5-accuracy: 0.6869 - val_loss: 2.9779 - val_accuracy: 0.3458 - val_top-5-accuracy: 0.6724 Epoch 14/40 352/352 [==============================] - 11s 31ms/step - loss: 2.8822 - accuracy: 0.3717 - top-5-accuracy: 0.6923 - val_loss: 2.9549 - val_accuracy: 0.3552 - val_top-5-accuracy: 0.6748 Epoch 15/40 352/352 [==============================] - 11s 31ms/step - loss: 2.8578 - accuracy: 0.3826 - top-5-accuracy: 0.6981 - val_loss: 2.9447 - val_accuracy: 0.3584 - val_top-5-accuracy: 0.6786 Epoch 16/40 352/352 [==============================] - 11s 31ms/step - loss: 2.8404 - accuracy: 0.3852 - top-5-accuracy: 0.7024 - val_loss: 2.9087 - val_accuracy: 0.3650 - val_top-5-accuracy: 0.6842 Epoch 17/40 352/352 [==============================] - 11s 31ms/step - loss: 2.8234 - accuracy: 0.3910 - top-5-accuracy: 0.7076 - val_loss: 2.8884 - val_accuracy: 0.3748 - val_top-5-accuracy: 0.6868 Epoch 18/40 352/352 [==============================] - 11s 31ms/step - loss: 2.8014 - accuracy: 0.3974 - top-5-accuracy: 0.7124 - val_loss: 2.8979 - val_accuracy: 0.3696 - val_top-5-accuracy: 0.6908 Epoch 19/40 352/352 [==============================] - 11s 31ms/step - loss: 2.7928 - accuracy: 0.3961 - top-5-accuracy: 0.7172 - val_loss: 2.8873 - val_accuracy: 0.3756 - val_top-5-accuracy: 0.6924 Epoch 20/40 352/352 [==============================] - 11s 31ms/step - loss: 2.7800 - accuracy: 0.4026 - top-5-accuracy: 0.7186 - val_loss: 2.8544 - val_accuracy: 0.3834 - val_top-5-accuracy: 0.7004 Epoch 21/40 352/352 [==============================] - 11s 31ms/step - loss: 2.7659 - accuracy: 0.4095 - top-5-accuracy: 0.7236 - val_loss: 2.8626 - val_accuracy: 0.3840 - val_top-5-accuracy: 0.6896 Epoch 22/40 352/352 [==============================] - 11s 31ms/step - loss: 2.7499 - accuracy: 0.4098 - top-5-accuracy: 0.7278 - val_loss: 2.8621 - val_accuracy: 0.3868 - val_top-5-accuracy: 0.6944 Epoch 23/40 352/352 [==============================] - 11s 31ms/step - loss: 2.7389 - accuracy: 0.4136 - top-5-accuracy: 0.7305 - val_loss: 2.8527 - val_accuracy: 0.3834 - val_top-5-accuracy: 0.7002 Epoch 24/40 352/352 [==============================] - 11s 31ms/step - loss: 2.7219 - accuracy: 0.4198 - top-5-accuracy: 0.7360 - val_loss: 2.9078 - val_accuracy: 0.3738 - val_top-5-accuracy: 0.6796 Epoch 25/40 352/352 [==============================] - 11s 32ms/step - loss: 2.7119 - accuracy: 0.4195 - top-5-accuracy: 0.7373 - val_loss: 2.8470 - val_accuracy: 0.3840 - val_top-5-accuracy: 0.6994 Epoch 26/40 352/352 [==============================] - 11s 32ms/step - loss: 2.7079 - accuracy: 0.4214 - top-5-accuracy: 0.7355 - val_loss: 2.8101 - val_accuracy: 0.3934 - val_top-5-accuracy: 0.7130 Epoch 27/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6925 - accuracy: 0.4280 - top-5-accuracy: 0.7398 - val_loss: 2.8660 - val_accuracy: 0.3804 - val_top-5-accuracy: 0.6996 Epoch 28/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6864 - accuracy: 0.4273 - top-5-accuracy: 0.7430 - val_loss: 2.7863 - val_accuracy: 0.4014 - val_top-5-accuracy: 0.7234 Epoch 29/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6763 - accuracy: 0.4324 - top-5-accuracy: 0.7472 - val_loss: 2.7852 - val_accuracy: 0.4030 - val_top-5-accuracy: 0.7158 Epoch 30/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6656 - accuracy: 0.4356 - top-5-accuracy: 0.7489 - val_loss: 2.7991 - val_accuracy: 0.3940 - val_top-5-accuracy: 0.7104 Epoch 31/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6589 - accuracy: 0.4383 - top-5-accuracy: 0.7512 - val_loss: 2.7938 - val_accuracy: 0.3966 - val_top-5-accuracy: 0.7148 Epoch 32/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6509 - accuracy: 0.4367 - top-5-accuracy: 0.7530 - val_loss: 2.8226 - val_accuracy: 0.3944 - val_top-5-accuracy: 0.7092 Epoch 33/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6384 - accuracy: 0.4432 - top-5-accuracy: 0.7565 - val_loss: 2.8171 - val_accuracy: 0.3964 - val_top-5-accuracy: 0.7060 Epoch 34/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6317 - accuracy: 0.4446 - top-5-accuracy: 0.7561 - val_loss: 2.7923 - val_accuracy: 0.3970 - val_top-5-accuracy: 0.7134 Epoch 35/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6241 - accuracy: 0.4447 - top-5-accuracy: 0.7574 - val_loss: 2.7664 - val_accuracy: 0.4108 - val_top-5-accuracy: 0.7180 Epoch 36/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6199 - accuracy: 0.4467 - top-5-accuracy: 0.7586 - val_loss: 2.7480 - val_accuracy: 0.4078 - val_top-5-accuracy: 0.7242 Epoch 37/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6127 - accuracy: 0.4506 - top-5-accuracy: 0.7608 - val_loss: 2.7651 - val_accuracy: 0.4052 - val_top-5-accuracy: 0.7218 Epoch 38/40 352/352 [==============================] - 11s 31ms/step - loss: 2.6025 - accuracy: 0.4520 - top-5-accuracy: 0.7620 - val_loss: 2.7641 - val_accuracy: 0.4114 - val_top-5-accuracy: 0.7254 Epoch 39/40 352/352 [==============================] - 11s 31ms/step - loss: 2.5934 - accuracy: 0.4542 - top-5-accuracy: 0.7670 - val_loss: 2.7453 - val_accuracy: 0.4120 - val_top-5-accuracy: 0.7200 Epoch 40/40 352/352 [==============================] - 11s 31ms/step - loss: 2.5859 - accuracy: 0.4565 - top-5-accuracy: 0.7688 - val_loss: 2.7504 - val_accuracy: 0.4118 - val_top-5-accuracy: 0.7268 Let's visualize the training progress of the model. plt.plot(history.history[\"loss\"], label=\"train_loss\") plt.plot(history.history[\"val_loss\"], label=\"val_loss\") plt.xlabel(\"Epochs\") plt.ylabel(\"Loss\") plt.title(\"Train and Validation Losses Over Epochs\", fontsize=14) plt.legend() plt.grid() plt.show() png Let's display the final results of the training on CIFAR-100. loss, accuracy, top_5_accuracy = model.evaluate(x_test, y_test) print(f\"Test loss: {round(loss, 2)}\") print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") print(f\"Test top 5 accuracy: {round(top_5_accuracy * 100, 2)}%\") 313/313 [==============================] - 3s 8ms/step - loss: 2.7039 - accuracy: 0.4288 - top-5-accuracy: 0.7366 Test loss: 2.7 Test accuracy: 42.88% Test top 5 accuracy: 73.66% The Swin Transformer model we just trained has just 152K parameters, and it gets us to ~75% test top-5 accuracy within just 40 epochs without any signs of overfitting as well as seen in above graph. This means we can train this network for longer (perhaps with a bit more regularization) and obtain even better performance. This performance can further be improved by additional techniques like cosine decay learning rate schedule, other data augmentation techniques. While experimenting, I tried training the model for 150 epochs with a slightly higher dropout and greater embedding dimensions which pushes the performance to ~72% test accuracy on CIFAR-100 as you can see in the screenshot. Results of training for longer The authors present a top-1 accuracy of 87.3% on ImageNet. The authors also present a number of experiments to study how input sizes, optimizers etc. affect the final performance of this model. The authors further present using this model for object detection, semantic segmentation and instance segmentation as well and report competitive results for these. You are strongly advised to also check out the original paper. This example takes inspiration from the official PyTorch and TensorFlow implementations. Implementing the Vision Transformer (ViT) model for image classification. Introduction This example implements the Vision Transformer (ViT) model by Alexey Dosovitskiy et al. for image classification, and demonstrates it on the CIFAR-100 dataset. The ViT model applies the Transformer architecture with self-attention to sequences of image patches, without using convolution layers. This example requires TensorFlow 2.4 or higher, as well as TensorFlow Addons, which can be installed using the following command: pip install -U tensorflow-addons Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_addons as tfa Prepare the data num_classes = 100 input_shape = (32, 32, 3) (x_train, y_train), (x_test, y_test) = keras.datasets.cifar100.load_data() print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\") print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\") x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 1) x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 1) Configure the hyperparameters learning_rate = 0.001 weight_decay = 0.0001 batch_size = 256 num_epochs = 100 image_size = 72 # We'll resize input images to this size patch_size = 6 # Size of the patches to be extract from the input images num_patches = (image_size // patch_size) ** 2 projection_dim = 64 num_heads = 4 transformer_units = [ projection_dim * 2, projection_dim, ] # Size of the transformer layers transformer_layers = 8 mlp_head_units = [2048, 1024] # Size of the dense layers of the final classifier Use data augmentation data_augmentation = keras.Sequential( [ layers.Normalization(), layers.Resizing(image_size, image_size), layers.RandomFlip(\"horizontal\"), layers.RandomRotation(factor=0.02), layers.RandomZoom( height_factor=0.2, width_factor=0.2 ), ], name=\"data_augmentation\", ) # Compute the mean and the variance of the training data for normalization. data_augmentation.layers[0].adapt(x_train) Implement multilayer perceptron (MLP) def mlp(x, hidden_units, dropout_rate): for units in hidden_units: x = layers.Dense(units, activation=tf.nn.gelu)(x) x = layers.Dropout(dropout_rate)(x) return x Implement patch creation as a layer class Patches(layers.Layer): def __init__(self, patch_size): super(Patches, self).__init__() self.patch_size = patch_size def call(self, images): batch_size = tf.shape(images)[0] patches = tf.image.extract_patches( images=images, sizes=[1, self.patch_size, self.patch_size, 1], strides=[1, self.patch_size, self.patch_size, 1], rates=[1, 1, 1, 1], padding=\"VALID\", ) patch_dims = patches.shape[-1] patches = tf.reshape(patches, [batch_size, -1, patch_dims]) return patches Let's display patches for a sample image import matplotlib.pyplot as plt plt.figure(figsize=(4, 4)) image = x_train[np.random.choice(range(x_train.shape[0]))] plt.imshow(image.astype(\"uint8\")) plt.axis(\"off\") resized_image = tf.image.resize( tf.convert_to_tensor([image]), size=(image_size, image_size) ) patches = Patches(patch_size)(resized_image) print(f\"Image size: {image_size} X {image_size}\") print(f\"Patch size: {patch_size} X {patch_size}\") print(f\"Patches per image: {patches.shape[1]}\") print(f\"Elements per patch: {patches.shape[-1]}\") n = int(np.sqrt(patches.shape[1])) plt.figure(figsize=(4, 4)) for i, patch in enumerate(patches[0]): ax = plt.subplot(n, n, i + 1) patch_img = tf.reshape(patch, (patch_size, patch_size, 3)) plt.imshow(patch_img.numpy().astype(\"uint8\")) plt.axis(\"off\") Image size: 72 X 72 Patch size: 6 X 6 Patches per image: 144 Elements per patch: 108 png png Implement the patch encoding layer The PatchEncoder layer will linearly transform a patch by projecting it into a vector of size projection_dim. In addition, it adds a learnable position embedding to the projected vector. class PatchEncoder(layers.Layer): def __init__(self, num_patches, projection_dim): super(PatchEncoder, self).__init__() self.num_patches = num_patches self.projection = layers.Dense(units=projection_dim) self.position_embedding = layers.Embedding( input_dim=num_patches, output_dim=projection_dim ) def call(self, patch): positions = tf.range(start=0, limit=self.num_patches, delta=1) encoded = self.projection(patch) + self.position_embedding(positions) return encoded Build the ViT model The ViT model consists of multiple Transformer blocks, which use the layers.MultiHeadAttention layer as a self-attention mechanism applied to the sequence of patches. The Transformer blocks produce a [batch_size, num_patches, projection_dim] tensor, which is processed via an classifier head with softmax to produce the final class probabilities output. Unlike the technique described in the paper, which prepends a learnable embedding to the sequence of encoded patches to serve as the image representation, all the outputs of the final Transformer block are reshaped with layers.Flatten() and used as the image representation input to the classifier head. Note that the layers.GlobalAveragePooling1D layer could also be used instead to aggregate the outputs of the Transformer block, especially when the number of patches and the projection dimensions are large. def create_vit_classifier(): inputs = layers.Input(shape=input_shape) # Augment data. augmented = data_augmentation(inputs) # Create patches. patches = Patches(patch_size)(augmented) # Encode patches. encoded_patches = PatchEncoder(num_patches, projection_dim)(patches) # Create multiple layers of the Transformer block. for _ in range(transformer_layers): # Layer normalization 1. x1 = layers.LayerNormalization(epsilon=1e-6)(encoded_patches) # Create a multi-head attention layer. attention_output = layers.MultiHeadAttention( num_heads=num_heads, key_dim=projection_dim, dropout=0.1 )(x1, x1) # Skip connection 1. x2 = layers.Add()([attention_output, encoded_patches]) # Layer normalization 2. x3 = layers.LayerNormalization(epsilon=1e-6)(x2) # MLP. x3 = mlp(x3, hidden_units=transformer_units, dropout_rate=0.1) # Skip connection 2. encoded_patches = layers.Add()([x3, x2]) # Create a [batch_size, projection_dim] tensor. representation = layers.LayerNormalization(epsilon=1e-6)(encoded_patches) representation = layers.Flatten()(representation) representation = layers.Dropout(0.5)(representation) # Add MLP. features = mlp(representation, hidden_units=mlp_head_units, dropout_rate=0.5) # Classify outputs. logits = layers.Dense(num_classes)(features) # Create the Keras model. model = keras.Model(inputs=inputs, outputs=logits) return model Compile, train, and evaluate the mode def run_experiment(model): optimizer = tfa.optimizers.AdamW( learning_rate=learning_rate, weight_decay=weight_decay ) model.compile( optimizer=optimizer, loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[ keras.metrics.SparseCategoricalAccuracy(name=\"accuracy\"), keras.metrics.SparseTopKCategoricalAccuracy(5, name=\"top-5-accuracy\"), ], ) checkpoint_filepath = \"/tmp/checkpoint\" checkpoint_callback = keras.callbacks.ModelCheckpoint( checkpoint_filepath, monitor=\"val_accuracy\", save_best_only=True, save_weights_only=True, ) history = model.fit( x=x_train, y=y_train, batch_size=batch_size, epochs=num_epochs, validation_split=0.1, callbacks=[checkpoint_callback], ) model.load_weights(checkpoint_filepath) _, accuracy, top_5_accuracy = model.evaluate(x_test, y_test) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") print(f\"Test top 5 accuracy: {round(top_5_accuracy * 100, 2)}%\") return history vit_classifier = create_vit_classifier() history = run_experiment(vit_classifier) Epoch 1/100 176/176 [==============================] - 33s 136ms/step - loss: 4.8863 - accuracy: 0.0294 - top-5-accuracy: 0.1117 - val_loss: 3.9661 - val_accuracy: 0.0992 - val_top-5-accuracy: 0.3056 Epoch 2/100 176/176 [==============================] - 22s 127ms/step - loss: 4.0162 - accuracy: 0.0865 - top-5-accuracy: 0.2683 - val_loss: 3.5691 - val_accuracy: 0.1630 - val_top-5-accuracy: 0.4226 Epoch 3/100 176/176 [==============================] - 22s 127ms/step - loss: 3.7313 - accuracy: 0.1254 - top-5-accuracy: 0.3535 - val_loss: 3.3455 - val_accuracy: 0.1976 - val_top-5-accuracy: 0.4756 Epoch 4/100 176/176 [==============================] - 23s 128ms/step - loss: 3.5411 - accuracy: 0.1541 - top-5-accuracy: 0.4121 - val_loss: 3.1925 - val_accuracy: 0.2274 - val_top-5-accuracy: 0.5126 Epoch 5/100 176/176 [==============================] - 22s 127ms/step - loss: 3.3749 - accuracy: 0.1847 - top-5-accuracy: 0.4572 - val_loss: 3.1043 - val_accuracy: 0.2388 - val_top-5-accuracy: 0.5320 Epoch 6/100 176/176 [==============================] - 22s 127ms/step - loss: 3.2589 - accuracy: 0.2057 - top-5-accuracy: 0.4906 - val_loss: 2.9319 - val_accuracy: 0.2782 - val_top-5-accuracy: 0.5756 Epoch 7/100 176/176 [==============================] - 22s 127ms/step - loss: 3.1165 - accuracy: 0.2331 - top-5-accuracy: 0.5273 - val_loss: 2.8072 - val_accuracy: 0.2972 - val_top-5-accuracy: 0.5946 Epoch 8/100 176/176 [==============================] - 22s 127ms/step - loss: 2.9902 - accuracy: 0.2563 - top-5-accuracy: 0.5556 - val_loss: 2.7207 - val_accuracy: 0.3188 - val_top-5-accuracy: 0.6258 Epoch 9/100 176/176 [==============================] - 22s 127ms/step - loss: 2.8828 - accuracy: 0.2800 - top-5-accuracy: 0.5827 - val_loss: 2.6396 - val_accuracy: 0.3244 - val_top-5-accuracy: 0.6402 Epoch 10/100 176/176 [==============================] - 23s 128ms/step - loss: 2.7824 - accuracy: 0.2997 - top-5-accuracy: 0.6110 - val_loss: 2.5580 - val_accuracy: 0.3494 - val_top-5-accuracy: 0.6568 Epoch 11/100 176/176 [==============================] - 23s 130ms/step - loss: 2.6743 - accuracy: 0.3209 - top-5-accuracy: 0.6333 - val_loss: 2.5000 - val_accuracy: 0.3594 - val_top-5-accuracy: 0.6726 Epoch 12/100 176/176 [==============================] - 23s 130ms/step - loss: 2.5800 - accuracy: 0.3431 - top-5-accuracy: 0.6522 - val_loss: 2.3900 - val_accuracy: 0.3798 - val_top-5-accuracy: 0.6878 Epoch 13/100 176/176 [==============================] - 23s 128ms/step - loss: 2.5019 - accuracy: 0.3559 - top-5-accuracy: 0.6671 - val_loss: 2.3464 - val_accuracy: 0.3960 - val_top-5-accuracy: 0.7002 Epoch 14/100 176/176 [==============================] - 22s 128ms/step - loss: 2.4207 - accuracy: 0.3728 - top-5-accuracy: 0.6905 - val_loss: 2.3130 - val_accuracy: 0.4032 - val_top-5-accuracy: 0.7040 Epoch 15/100 176/176 [==============================] - 23s 128ms/step - loss: 2.3371 - accuracy: 0.3932 - top-5-accuracy: 0.7093 - val_loss: 2.2447 - val_accuracy: 0.4136 - val_top-5-accuracy: 0.7202 Epoch 16/100 176/176 [==============================] - 23s 128ms/step - loss: 2.2650 - accuracy: 0.4077 - top-5-accuracy: 0.7201 - val_loss: 2.2101 - val_accuracy: 0.4222 - val_top-5-accuracy: 0.7246 Epoch 17/100 176/176 [==============================] - 22s 127ms/step - loss: 2.1822 - accuracy: 0.4204 - top-5-accuracy: 0.7376 - val_loss: 2.1446 - val_accuracy: 0.4344 - val_top-5-accuracy: 0.7416 Epoch 18/100 176/176 [==============================] - 22s 128ms/step - loss: 2.1485 - accuracy: 0.4284 - top-5-accuracy: 0.7476 - val_loss: 2.1094 - val_accuracy: 0.4432 - val_top-5-accuracy: 0.7454 Epoch 19/100 176/176 [==============================] - 22s 128ms/step - loss: 2.0717 - accuracy: 0.4464 - top-5-accuracy: 0.7618 - val_loss: 2.0718 - val_accuracy: 0.4584 - val_top-5-accuracy: 0.7570 Epoch 20/100 176/176 [==============================] - 22s 127ms/step - loss: 2.0031 - accuracy: 0.4605 - top-5-accuracy: 0.7731 - val_loss: 2.0286 - val_accuracy: 0.4610 - val_top-5-accuracy: 0.7654 Epoch 21/100 176/176 [==============================] - 22s 127ms/step - loss: 1.9650 - accuracy: 0.4700 - top-5-accuracy: 0.7820 - val_loss: 2.0225 - val_accuracy: 0.4642 - val_top-5-accuracy: 0.7628 Epoch 22/100 176/176 [==============================] - 22s 127ms/step - loss: 1.9066 - accuracy: 0.4839 - top-5-accuracy: 0.7904 - val_loss: 1.9961 - val_accuracy: 0.4746 - val_top-5-accuracy: 0.7656 Epoch 23/100 176/176 [==============================] - 22s 127ms/step - loss: 1.8564 - accuracy: 0.4952 - top-5-accuracy: 0.8030 - val_loss: 1.9769 - val_accuracy: 0.4828 - val_top-5-accuracy: 0.7742 Epoch 24/100 176/176 [==============================] - 22s 128ms/step - loss: 1.8167 - accuracy: 0.5034 - top-5-accuracy: 0.8099 - val_loss: 1.9730 - val_accuracy: 0.4766 - val_top-5-accuracy: 0.7728 Epoch 25/100 176/176 [==============================] - 22s 128ms/step - loss: 1.7788 - accuracy: 0.5124 - top-5-accuracy: 0.8174 - val_loss: 1.9187 - val_accuracy: 0.4926 - val_top-5-accuracy: 0.7854 Epoch 26/100 176/176 [==============================] - 23s 128ms/step - loss: 1.7437 - accuracy: 0.5187 - top-5-accuracy: 0.8206 - val_loss: 1.9732 - val_accuracy: 0.4792 - val_top-5-accuracy: 0.7772 Epoch 27/100 176/176 [==============================] - 23s 128ms/step - loss: 1.6929 - accuracy: 0.5300 - top-5-accuracy: 0.8287 - val_loss: 1.9109 - val_accuracy: 0.4928 - val_top-5-accuracy: 0.7912 Epoch 28/100 176/176 [==============================] - 23s 129ms/step - loss: 1.6647 - accuracy: 0.5400 - top-5-accuracy: 0.8362 - val_loss: 1.9031 - val_accuracy: 0.4984 - val_top-5-accuracy: 0.7824 Epoch 29/100 176/176 [==============================] - 23s 129ms/step - loss: 1.6295 - accuracy: 0.5488 - top-5-accuracy: 0.8402 - val_loss: 1.8744 - val_accuracy: 0.4982 - val_top-5-accuracy: 0.7910 Epoch 30/100 176/176 [==============================] - 22s 128ms/step - loss: 1.5860 - accuracy: 0.5548 - top-5-accuracy: 0.8504 - val_loss: 1.8551 - val_accuracy: 0.5108 - val_top-5-accuracy: 0.7946 Epoch 31/100 176/176 [==============================] - 22s 127ms/step - loss: 1.5666 - accuracy: 0.5614 - top-5-accuracy: 0.8548 - val_loss: 1.8720 - val_accuracy: 0.5076 - val_top-5-accuracy: 0.7960 Epoch 32/100 176/176 [==============================] - 22s 127ms/step - loss: 1.5272 - accuracy: 0.5712 - top-5-accuracy: 0.8596 - val_loss: 1.8840 - val_accuracy: 0.5106 - val_top-5-accuracy: 0.7966 Epoch 33/100 176/176 [==============================] - 22s 128ms/step - loss: 1.4995 - accuracy: 0.5779 - top-5-accuracy: 0.8651 - val_loss: 1.8660 - val_accuracy: 0.5116 - val_top-5-accuracy: 0.7904 Epoch 34/100 176/176 [==============================] - 22s 128ms/step - loss: 1.4686 - accuracy: 0.5849 - top-5-accuracy: 0.8685 - val_loss: 1.8544 - val_accuracy: 0.5126 - val_top-5-accuracy: 0.7954 Epoch 35/100 176/176 [==============================] - 22s 127ms/step - loss: 1.4276 - accuracy: 0.5992 - top-5-accuracy: 0.8743 - val_loss: 1.8497 - val_accuracy: 0.5164 - val_top-5-accuracy: 0.7990 Epoch 36/100 176/176 [==============================] - 22s 127ms/step - loss: 1.4102 - accuracy: 0.5970 - top-5-accuracy: 0.8768 - val_loss: 1.8496 - val_accuracy: 0.5198 - val_top-5-accuracy: 0.7948 Epoch 37/100 176/176 [==============================] - 22s 126ms/step - loss: 1.3800 - accuracy: 0.6112 - top-5-accuracy: 0.8814 - val_loss: 1.8033 - val_accuracy: 0.5284 - val_top-5-accuracy: 0.8068 Epoch 38/100 176/176 [==============================] - 22s 126ms/step - loss: 1.3500 - accuracy: 0.6103 - top-5-accuracy: 0.8862 - val_loss: 1.8092 - val_accuracy: 0.5214 - val_top-5-accuracy: 0.8128 Epoch 39/100 176/176 [==============================] - 22s 127ms/step - loss: 1.3575 - accuracy: 0.6127 - top-5-accuracy: 0.8857 - val_loss: 1.8175 - val_accuracy: 0.5198 - val_top-5-accuracy: 0.8086 Epoch 40/100 176/176 [==============================] - 22s 126ms/step - loss: 1.3030 - accuracy: 0.6283 - top-5-accuracy: 0.8927 - val_loss: 1.8361 - val_accuracy: 0.5170 - val_top-5-accuracy: 0.8056 Epoch 41/100 176/176 [==============================] - 22s 125ms/step - loss: 1.3160 - accuracy: 0.6247 - top-5-accuracy: 0.8923 - val_loss: 1.8074 - val_accuracy: 0.5260 - val_top-5-accuracy: 0.8082 Epoch 42/100 176/176 [==============================] - 22s 126ms/step - loss: 1.2679 - accuracy: 0.6329 - top-5-accuracy: 0.9002 - val_loss: 1.8430 - val_accuracy: 0.5244 - val_top-5-accuracy: 0.8100 Epoch 43/100 176/176 [==============================] - 22s 126ms/step - loss: 1.2514 - accuracy: 0.6375 - top-5-accuracy: 0.9034 - val_loss: 1.8318 - val_accuracy: 0.5196 - val_top-5-accuracy: 0.8034 Epoch 44/100 176/176 [==============================] - 22s 126ms/step - loss: 1.2311 - accuracy: 0.6431 - top-5-accuracy: 0.9067 - val_loss: 1.8283 - val_accuracy: 0.5218 - val_top-5-accuracy: 0.8050 Epoch 45/100 176/176 [==============================] - 22s 125ms/step - loss: 1.2073 - accuracy: 0.6484 - top-5-accuracy: 0.9098 - val_loss: 1.8384 - val_accuracy: 0.5302 - val_top-5-accuracy: 0.8056 Epoch 46/100 176/176 [==============================] - 22s 125ms/step - loss: 1.1775 - accuracy: 0.6558 - top-5-accuracy: 0.9117 - val_loss: 1.8409 - val_accuracy: 0.5294 - val_top-5-accuracy: 0.8078 Epoch 47/100 176/176 [==============================] - 22s 126ms/step - loss: 1.1891 - accuracy: 0.6563 - top-5-accuracy: 0.9103 - val_loss: 1.8167 - val_accuracy: 0.5346 - val_top-5-accuracy: 0.8142 Epoch 48/100 176/176 [==============================] - 22s 127ms/step - loss: 1.1586 - accuracy: 0.6621 - top-5-accuracy: 0.9161 - val_loss: 1.8285 - val_accuracy: 0.5314 - val_top-5-accuracy: 0.8086 Epoch 49/100 176/176 [==============================] - 22s 126ms/step - loss: 1.1586 - accuracy: 0.6634 - top-5-accuracy: 0.9154 - val_loss: 1.8189 - val_accuracy: 0.5366 - val_top-5-accuracy: 0.8134 Epoch 50/100 176/176 [==============================] - 22s 126ms/step - loss: 1.1306 - accuracy: 0.6682 - top-5-accuracy: 0.9199 - val_loss: 1.8442 - val_accuracy: 0.5254 - val_top-5-accuracy: 0.8096 Epoch 51/100 176/176 [==============================] - 22s 126ms/step - loss: 1.1175 - accuracy: 0.6708 - top-5-accuracy: 0.9227 - val_loss: 1.8513 - val_accuracy: 0.5230 - val_top-5-accuracy: 0.8104 Epoch 52/100 176/176 [==============================] - 22s 126ms/step - loss: 1.1104 - accuracy: 0.6743 - top-5-accuracy: 0.9226 - val_loss: 1.8041 - val_accuracy: 0.5332 - val_top-5-accuracy: 0.8142 Epoch 53/100 176/176 [==============================] - 22s 127ms/step - loss: 1.0914 - accuracy: 0.6809 - top-5-accuracy: 0.9236 - val_loss: 1.8213 - val_accuracy: 0.5342 - val_top-5-accuracy: 0.8094 Epoch 54/100 176/176 [==============================] - 22s 126ms/step - loss: 1.0681 - accuracy: 0.6856 - top-5-accuracy: 0.9270 - val_loss: 1.8429 - val_accuracy: 0.5328 - val_top-5-accuracy: 0.8086 Epoch 55/100 176/176 [==============================] - 22s 126ms/step - loss: 1.0625 - accuracy: 0.6862 - top-5-accuracy: 0.9301 - val_loss: 1.8316 - val_accuracy: 0.5364 - val_top-5-accuracy: 0.8090 Epoch 56/100 176/176 [==============================] - 22s 127ms/step - loss: 1.0474 - accuracy: 0.6920 - top-5-accuracy: 0.9308 - val_loss: 1.8310 - val_accuracy: 0.5440 - val_top-5-accuracy: 0.8132 Epoch 57/100 176/176 [==============================] - 22s 127ms/step - loss: 1.0381 - accuracy: 0.6974 - top-5-accuracy: 0.9297 - val_loss: 1.8447 - val_accuracy: 0.5368 - val_top-5-accuracy: 0.8126 Epoch 58/100 176/176 [==============================] - 22s 126ms/step - loss: 1.0230 - accuracy: 0.7011 - top-5-accuracy: 0.9341 - val_loss: 1.8241 - val_accuracy: 0.5418 - val_top-5-accuracy: 0.8094 Epoch 59/100 176/176 [==============================] - 22s 127ms/step - loss: 1.0113 - accuracy: 0.7023 - top-5-accuracy: 0.9361 - val_loss: 1.8216 - val_accuracy: 0.5380 - val_top-5-accuracy: 0.8134 Epoch 60/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9953 - accuracy: 0.7031 - top-5-accuracy: 0.9386 - val_loss: 1.8356 - val_accuracy: 0.5422 - val_top-5-accuracy: 0.8122 Epoch 61/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9928 - accuracy: 0.7084 - top-5-accuracy: 0.9375 - val_loss: 1.8514 - val_accuracy: 0.5342 - val_top-5-accuracy: 0.8182 Epoch 62/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9740 - accuracy: 0.7121 - top-5-accuracy: 0.9387 - val_loss: 1.8674 - val_accuracy: 0.5366 - val_top-5-accuracy: 0.8092 Epoch 63/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9742 - accuracy: 0.7112 - top-5-accuracy: 0.9413 - val_loss: 1.8274 - val_accuracy: 0.5414 - val_top-5-accuracy: 0.8144 Epoch 64/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9633 - accuracy: 0.7147 - top-5-accuracy: 0.9393 - val_loss: 1.8250 - val_accuracy: 0.5434 - val_top-5-accuracy: 0.8180 Epoch 65/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9407 - accuracy: 0.7221 - top-5-accuracy: 0.9444 - val_loss: 1.8456 - val_accuracy: 0.5424 - val_top-5-accuracy: 0.8120 Epoch 66/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9410 - accuracy: 0.7194 - top-5-accuracy: 0.9447 - val_loss: 1.8559 - val_accuracy: 0.5460 - val_top-5-accuracy: 0.8144 Epoch 67/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9359 - accuracy: 0.7252 - top-5-accuracy: 0.9421 - val_loss: 1.8352 - val_accuracy: 0.5458 - val_top-5-accuracy: 0.8110 Epoch 68/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9232 - accuracy: 0.7254 - top-5-accuracy: 0.9460 - val_loss: 1.8479 - val_accuracy: 0.5444 - val_top-5-accuracy: 0.8132 Epoch 69/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9138 - accuracy: 0.7283 - top-5-accuracy: 0.9456 - val_loss: 1.8697 - val_accuracy: 0.5312 - val_top-5-accuracy: 0.8052 Epoch 70/100 176/176 [==============================] - 22s 126ms/step - loss: 0.9095 - accuracy: 0.7295 - top-5-accuracy: 0.9478 - val_loss: 1.8550 - val_accuracy: 0.5376 - val_top-5-accuracy: 0.8170 Epoch 71/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8945 - accuracy: 0.7332 - top-5-accuracy: 0.9504 - val_loss: 1.8286 - val_accuracy: 0.5436 - val_top-5-accuracy: 0.8198 Epoch 72/100 176/176 [==============================] - 22s 125ms/step - loss: 0.8936 - accuracy: 0.7344 - top-5-accuracy: 0.9479 - val_loss: 1.8727 - val_accuracy: 0.5438 - val_top-5-accuracy: 0.8182 Epoch 73/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8775 - accuracy: 0.7355 - top-5-accuracy: 0.9510 - val_loss: 1.8522 - val_accuracy: 0.5404 - val_top-5-accuracy: 0.8170 Epoch 74/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8660 - accuracy: 0.7390 - top-5-accuracy: 0.9513 - val_loss: 1.8432 - val_accuracy: 0.5448 - val_top-5-accuracy: 0.8156 Epoch 75/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8583 - accuracy: 0.7441 - top-5-accuracy: 0.9532 - val_loss: 1.8419 - val_accuracy: 0.5462 - val_top-5-accuracy: 0.8226 Epoch 76/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8549 - accuracy: 0.7443 - top-5-accuracy: 0.9529 - val_loss: 1.8757 - val_accuracy: 0.5454 - val_top-5-accuracy: 0.8086 Epoch 77/100 176/176 [==============================] - 22s 125ms/step - loss: 0.8578 - accuracy: 0.7384 - top-5-accuracy: 0.9531 - val_loss: 1.9051 - val_accuracy: 0.5462 - val_top-5-accuracy: 0.8136 Epoch 78/100 176/176 [==============================] - 22s 125ms/step - loss: 0.8530 - accuracy: 0.7442 - top-5-accuracy: 0.9526 - val_loss: 1.8496 - val_accuracy: 0.5384 - val_top-5-accuracy: 0.8124 Epoch 79/100 176/176 [==============================] - 22s 125ms/step - loss: 0.8403 - accuracy: 0.7485 - top-5-accuracy: 0.9542 - val_loss: 1.8701 - val_accuracy: 0.5550 - val_top-5-accuracy: 0.8228 Epoch 80/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8410 - accuracy: 0.7491 - top-5-accuracy: 0.9538 - val_loss: 1.8737 - val_accuracy: 0.5502 - val_top-5-accuracy: 0.8150 Epoch 81/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8275 - accuracy: 0.7547 - top-5-accuracy: 0.9532 - val_loss: 1.8391 - val_accuracy: 0.5534 - val_top-5-accuracy: 0.8156 Epoch 82/100 176/176 [==============================] - 22s 125ms/step - loss: 0.8221 - accuracy: 0.7528 - top-5-accuracy: 0.9562 - val_loss: 1.8775 - val_accuracy: 0.5428 - val_top-5-accuracy: 0.8120 Epoch 83/100 176/176 [==============================] - 22s 125ms/step - loss: 0.8270 - accuracy: 0.7526 - top-5-accuracy: 0.9550 - val_loss: 1.8464 - val_accuracy: 0.5468 - val_top-5-accuracy: 0.8148 Epoch 84/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8080 - accuracy: 0.7551 - top-5-accuracy: 0.9576 - val_loss: 1.8789 - val_accuracy: 0.5486 - val_top-5-accuracy: 0.8204 Epoch 85/100 176/176 [==============================] - 22s 125ms/step - loss: 0.8058 - accuracy: 0.7593 - top-5-accuracy: 0.9573 - val_loss: 1.8691 - val_accuracy: 0.5446 - val_top-5-accuracy: 0.8156 Epoch 86/100 176/176 [==============================] - 22s 126ms/step - loss: 0.8092 - accuracy: 0.7564 - top-5-accuracy: 0.9560 - val_loss: 1.8588 - val_accuracy: 0.5524 - val_top-5-accuracy: 0.8172 Epoch 87/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7897 - accuracy: 0.7613 - top-5-accuracy: 0.9604 - val_loss: 1.8649 - val_accuracy: 0.5490 - val_top-5-accuracy: 0.8166 Epoch 88/100 176/176 [==============================] - 22s 126ms/step - loss: 0.7890 - accuracy: 0.7635 - top-5-accuracy: 0.9598 - val_loss: 1.9060 - val_accuracy: 0.5446 - val_top-5-accuracy: 0.8112 Epoch 89/100 176/176 [==============================] - 22s 126ms/step - loss: 0.7682 - accuracy: 0.7687 - top-5-accuracy: 0.9620 - val_loss: 1.8645 - val_accuracy: 0.5474 - val_top-5-accuracy: 0.8150 Epoch 90/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7958 - accuracy: 0.7617 - top-5-accuracy: 0.9600 - val_loss: 1.8549 - val_accuracy: 0.5496 - val_top-5-accuracy: 0.8140 Epoch 91/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7978 - accuracy: 0.7603 - top-5-accuracy: 0.9590 - val_loss: 1.9169 - val_accuracy: 0.5440 - val_top-5-accuracy: 0.8140 Epoch 92/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7898 - accuracy: 0.7630 - top-5-accuracy: 0.9594 - val_loss: 1.9015 - val_accuracy: 0.5540 - val_top-5-accuracy: 0.8174 Epoch 93/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7550 - accuracy: 0.7722 - top-5-accuracy: 0.9622 - val_loss: 1.9219 - val_accuracy: 0.5410 - val_top-5-accuracy: 0.8098 Epoch 94/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7692 - accuracy: 0.7689 - top-5-accuracy: 0.9599 - val_loss: 1.8928 - val_accuracy: 0.5506 - val_top-5-accuracy: 0.8184 Epoch 95/100 176/176 [==============================] - 22s 126ms/step - loss: 0.7783 - accuracy: 0.7661 - top-5-accuracy: 0.9597 - val_loss: 1.8646 - val_accuracy: 0.5490 - val_top-5-accuracy: 0.8166 Epoch 96/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7547 - accuracy: 0.7711 - top-5-accuracy: 0.9638 - val_loss: 1.9347 - val_accuracy: 0.5484 - val_top-5-accuracy: 0.8150 Epoch 97/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7603 - accuracy: 0.7692 - top-5-accuracy: 0.9616 - val_loss: 1.8966 - val_accuracy: 0.5522 - val_top-5-accuracy: 0.8144 Epoch 98/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7595 - accuracy: 0.7730 - top-5-accuracy: 0.9610 - val_loss: 1.8728 - val_accuracy: 0.5470 - val_top-5-accuracy: 0.8170 Epoch 99/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7542 - accuracy: 0.7736 - top-5-accuracy: 0.9622 - val_loss: 1.9132 - val_accuracy: 0.5504 - val_top-5-accuracy: 0.8156 Epoch 100/100 176/176 [==============================] - 22s 125ms/step - loss: 0.7410 - accuracy: 0.7787 - top-5-accuracy: 0.9635 - val_loss: 1.9233 - val_accuracy: 0.5428 - val_top-5-accuracy: 0.8120 313/313 [==============================] - 4s 12ms/step - loss: 1.8487 - accuracy: 0.5514 - top-5-accuracy: 0.8186 Test accuracy: 55.14% Test top 5 accuracy: 81.86% After 100 epochs, the ViT model achieves around 55% accuracy and 82% top-5 accuracy on the test data. These are not competitive results on the CIFAR-100 dataset, as a ResNet50V2 trained from scratch on the same data can achieve 67% accuracy. Note that the state of the art results reported in the paper are achieved by pre-training the ViT model using the JFT-300M dataset, then fine-tuning it on the target dataset. To improve the model quality without pre-training, you can try to train the model for more epochs, use a larger number of Transformer layers, resize the input images, change the patch size, or increase the projection dimensions. Besides, as mentioned in the paper, the quality of the model is affected not only by architecture choices, but also by parameters such as the learning rate schedule, optimizer, weight decay, etc. In practice, it's recommended to fine-tune a ViT model that was pre-trained using a large, high-resolution dataset. Image segmentation model trained from scratch on the Oxford Pets dataset Download the data !curl -O https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz !curl -O https://www.robots.ox.ac.uk/~vgg/data/pets/data/annotations.tar.gz !tar -xf images.tar.gz !tar -xf annotations.tar.gz % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 755M 100 755M 0 0 6943k 0 0:01:51 0:01:51 --:--:-- 7129k % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 18.2M 100 18.2M 0 0 5692k 0 0:00:03 0:00:03 --:--:-- 5692k Prepare paths of input images and target segmentation masks import os input_dir = \"images/\" target_dir = \"annotations/trimaps/\" img_size = (160, 160) num_classes = 3 batch_size = 32 input_img_paths = sorted( [ os.path.join(input_dir, fname) for fname in os.listdir(input_dir) if fname.endswith(\".jpg\") ] ) target_img_paths = sorted( [ os.path.join(target_dir, fname) for fname in os.listdir(target_dir) if fname.endswith(\".png\") and not fname.startswith(\".\") ] ) print(\"Number of samples:\", len(input_img_paths)) for input_path, target_path in zip(input_img_paths[:10], target_img_paths[:10]): print(input_path, \"|\", target_path) Number of samples: 7390 images/Abyssinian_1.jpg | annotations/trimaps/Abyssinian_1.png images/Abyssinian_10.jpg | annotations/trimaps/Abyssinian_10.png images/Abyssinian_100.jpg | annotations/trimaps/Abyssinian_100.png images/Abyssinian_101.jpg | annotations/trimaps/Abyssinian_101.png images/Abyssinian_102.jpg | annotations/trimaps/Abyssinian_102.png images/Abyssinian_103.jpg | annotations/trimaps/Abyssinian_103.png images/Abyssinian_104.jpg | annotations/trimaps/Abyssinian_104.png images/Abyssinian_105.jpg | annotations/trimaps/Abyssinian_105.png images/Abyssinian_106.jpg | annotations/trimaps/Abyssinian_106.png images/Abyssinian_107.jpg | annotations/trimaps/Abyssinian_107.png What does one input image and corresponding segmentation mask look like? from IPython.display import Image, display from tensorflow.keras.preprocessing.image import load_img import PIL from PIL import ImageOps # Display input image #7 display(Image(filename=input_img_paths[9])) # Display auto-contrast version of corresponding target (per-pixel categories) img = PIL.ImageOps.autocontrast(load_img(target_img_paths[9])) display(img) jpeg png Prepare Sequence class to load & vectorize batches of data from tensorflow import keras import numpy as np from tensorflow.keras.preprocessing.image import load_img class OxfordPets(keras.utils.Sequence): \"\"\"Helper to iterate over the data (as Numpy arrays).\"\"\" def __init__(self, batch_size, img_size, input_img_paths, target_img_paths): self.batch_size = batch_size self.img_size = img_size self.input_img_paths = input_img_paths self.target_img_paths = target_img_paths def __len__(self): return len(self.target_img_paths) // self.batch_size def __getitem__(self, idx): \"\"\"Returns tuple (input, target) correspond to batch #idx.\"\"\" i = idx * self.batch_size batch_input_img_paths = self.input_img_paths[i : i + self.batch_size] batch_target_img_paths = self.target_img_paths[i : i + self.batch_size] x = np.zeros((self.batch_size,) + self.img_size + (3,), dtype=\"float32\") for j, path in enumerate(batch_input_img_paths): img = load_img(path, target_size=self.img_size) x[j] = img y = np.zeros((self.batch_size,) + self.img_size + (1,), dtype=\"uint8\") for j, path in enumerate(batch_target_img_paths): img = load_img(path, target_size=self.img_size, color_mode=\"grayscale\") y[j] = np.expand_dims(img, 2) # Ground truth labels are 1, 2, 3. Subtract one to make them 0, 1, 2: y[j] -= 1 return x, y Prepare U-Net Xception-style model from tensorflow.keras import layers def get_model(img_size, num_classes): inputs = keras.Input(shape=img_size + (3,)) ### [First half of the network: downsampling inputs] ### # Entry block x = layers.Conv2D(32, 3, strides=2, padding=\"same\")(inputs) x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) previous_block_activation = x # Set aside residual # Blocks 1, 2, 3 are identical apart from the feature depth. for filters in [64, 128, 256]: x = layers.Activation(\"relu\")(x) x = layers.SeparableConv2D(filters, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) x = layers.SeparableConv2D(filters, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.MaxPooling2D(3, strides=2, padding=\"same\")(x) # Project residual residual = layers.Conv2D(filters, 1, strides=2, padding=\"same\")( previous_block_activation ) x = layers.add([x, residual]) # Add back residual previous_block_activation = x # Set aside next residual ### [Second half of the network: upsampling inputs] ### for filters in [256, 128, 64, 32]: x = layers.Activation(\"relu\")(x) x = layers.Conv2DTranspose(filters, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) x = layers.Conv2DTranspose(filters, 3, padding=\"same\")(x) x = layers.BatchNormalization()(x) x = layers.UpSampling2D(2)(x) # Project residual residual = layers.UpSampling2D(2)(previous_block_activation) residual = layers.Conv2D(filters, 1, padding=\"same\")(residual) x = layers.add([x, residual]) # Add back residual previous_block_activation = x # Set aside next residual # Add a per-pixel classification layer outputs = layers.Conv2D(num_classes, 3, activation=\"softmax\", padding=\"same\")(x) # Define the model model = keras.Model(inputs, outputs) return model # Free up RAM in case the model definition cells were run multiple times keras.backend.clear_session() # Build model model = get_model(img_size, num_classes) model.summary() Model: \"functional_1\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 160, 160, 3) 0 __________________________________________________________________________________________________ conv2d (Conv2D) (None, 80, 80, 32) 896 input_1[0][0] __________________________________________________________________________________________________ batch_normalization (BatchNorma (None, 80, 80, 32) 128 conv2d[0][0] __________________________________________________________________________________________________ activation (Activation) (None, 80, 80, 32) 0 batch_normalization[0][0] __________________________________________________________________________________________________ activation_1 (Activation) (None, 80, 80, 32) 0 activation[0][0] __________________________________________________________________________________________________ separable_conv2d (SeparableConv (None, 80, 80, 64) 2400 activation_1[0][0] __________________________________________________________________________________________________ batch_normalization_1 (BatchNor (None, 80, 80, 64) 256 separable_conv2d[0][0] __________________________________________________________________________________________________ activation_2 (Activation) (None, 80, 80, 64) 0 batch_normalization_1[0][0] __________________________________________________________________________________________________ separable_conv2d_1 (SeparableCo (None, 80, 80, 64) 4736 activation_2[0][0] __________________________________________________________________________________________________ batch_normalization_2 (BatchNor (None, 80, 80, 64) 256 separable_conv2d_1[0][0] __________________________________________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 40, 40, 64) 0 batch_normalization_2[0][0] __________________________________________________________________________________________________ conv2d_1 (Conv2D) (None, 40, 40, 64) 2112 activation[0][0] __________________________________________________________________________________________________ add (Add) (None, 40, 40, 64) 0 max_pooling2d[0][0] conv2d_1[0][0] __________________________________________________________________________________________________ activation_3 (Activation) (None, 40, 40, 64) 0 add[0][0] __________________________________________________________________________________________________ separable_conv2d_2 (SeparableCo (None, 40, 40, 128) 8896 activation_3[0][0] __________________________________________________________________________________________________ batch_normalization_3 (BatchNor (None, 40, 40, 128) 512 separable_conv2d_2[0][0] __________________________________________________________________________________________________ activation_4 (Activation) (None, 40, 40, 128) 0 batch_normalization_3[0][0] __________________________________________________________________________________________________ separable_conv2d_3 (SeparableCo (None, 40, 40, 128) 17664 activation_4[0][0] __________________________________________________________________________________________________ batch_normalization_4 (BatchNor (None, 40, 40, 128) 512 separable_conv2d_3[0][0] __________________________________________________________________________________________________ max_pooling2d_1 (MaxPooling2D) (None, 20, 20, 128) 0 batch_normalization_4[0][0] __________________________________________________________________________________________________ conv2d_2 (Conv2D) (None, 20, 20, 128) 8320 add[0][0] __________________________________________________________________________________________________ add_1 (Add) (None, 20, 20, 128) 0 max_pooling2d_1[0][0] conv2d_2[0][0] __________________________________________________________________________________________________ activation_5 (Activation) (None, 20, 20, 128) 0 add_1[0][0] __________________________________________________________________________________________________ separable_conv2d_4 (SeparableCo (None, 20, 20, 256) 34176 activation_5[0][0] __________________________________________________________________________________________________ batch_normalization_5 (BatchNor (None, 20, 20, 256) 1024 separable_conv2d_4[0][0] __________________________________________________________________________________________________ activation_6 (Activation) (None, 20, 20, 256) 0 batch_normalization_5[0][0] __________________________________________________________________________________________________ separable_conv2d_5 (SeparableCo (None, 20, 20, 256) 68096 activation_6[0][0] __________________________________________________________________________________________________ batch_normalization_6 (BatchNor (None, 20, 20, 256) 1024 separable_conv2d_5[0][0] __________________________________________________________________________________________________ max_pooling2d_2 (MaxPooling2D) (None, 10, 10, 256) 0 batch_normalization_6[0][0] __________________________________________________________________________________________________ conv2d_3 (Conv2D) (None, 10, 10, 256) 33024 add_1[0][0] __________________________________________________________________________________________________ add_2 (Add) (None, 10, 10, 256) 0 max_pooling2d_2[0][0] conv2d_3[0][0] __________________________________________________________________________________________________ activation_7 (Activation) (None, 10, 10, 256) 0 add_2[0][0] __________________________________________________________________________________________________ conv2d_transpose (Conv2DTranspo (None, 10, 10, 256) 590080 activation_7[0][0] __________________________________________________________________________________________________ batch_normalization_7 (BatchNor (None, 10, 10, 256) 1024 conv2d_transpose[0][0] __________________________________________________________________________________________________ activation_8 (Activation) (None, 10, 10, 256) 0 batch_normalization_7[0][0] __________________________________________________________________________________________________ conv2d_transpose_1 (Conv2DTrans (None, 10, 10, 256) 590080 activation_8[0][0] __________________________________________________________________________________________________ batch_normalization_8 (BatchNor (None, 10, 10, 256) 1024 conv2d_transpose_1[0][0] __________________________________________________________________________________________________ up_sampling2d_1 (UpSampling2D) (None, 20, 20, 256) 0 add_2[0][0] __________________________________________________________________________________________________ up_sampling2d (UpSampling2D) (None, 20, 20, 256) 0 batch_normalization_8[0][0] __________________________________________________________________________________________________ conv2d_4 (Conv2D) (None, 20, 20, 256) 65792 up_sampling2d_1[0][0] __________________________________________________________________________________________________ add_3 (Add) (None, 20, 20, 256) 0 up_sampling2d[0][0] conv2d_4[0][0] __________________________________________________________________________________________________ activation_9 (Activation) (None, 20, 20, 256) 0 add_3[0][0] __________________________________________________________________________________________________ conv2d_transpose_2 (Conv2DTrans (None, 20, 20, 128) 295040 activation_9[0][0] __________________________________________________________________________________________________ batch_normalization_9 (BatchNor (None, 20, 20, 128) 512 conv2d_transpose_2[0][0] __________________________________________________________________________________________________ activation_10 (Activation) (None, 20, 20, 128) 0 batch_normalization_9[0][0] __________________________________________________________________________________________________ conv2d_transpose_3 (Conv2DTrans (None, 20, 20, 128) 147584 activation_10[0][0] __________________________________________________________________________________________________ batch_normalization_10 (BatchNo (None, 20, 20, 128) 512 conv2d_transpose_3[0][0] __________________________________________________________________________________________________ up_sampling2d_3 (UpSampling2D) (None, 40, 40, 256) 0 add_3[0][0] __________________________________________________________________________________________________ up_sampling2d_2 (UpSampling2D) (None, 40, 40, 128) 0 batch_normalization_10[0][0] __________________________________________________________________________________________________ conv2d_5 (Conv2D) (None, 40, 40, 128) 32896 up_sampling2d_3[0][0] __________________________________________________________________________________________________ add_4 (Add) (None, 40, 40, 128) 0 up_sampling2d_2[0][0] conv2d_5[0][0] __________________________________________________________________________________________________ activation_11 (Activation) (None, 40, 40, 128) 0 add_4[0][0] __________________________________________________________________________________________________ conv2d_transpose_4 (Conv2DTrans (None, 40, 40, 64) 73792 activation_11[0][0] __________________________________________________________________________________________________ batch_normalization_11 (BatchNo (None, 40, 40, 64) 256 conv2d_transpose_4[0][0] __________________________________________________________________________________________________ activation_12 (Activation) (None, 40, 40, 64) 0 batch_normalization_11[0][0] __________________________________________________________________________________________________ conv2d_transpose_5 (Conv2DTrans (None, 40, 40, 64) 36928 activation_12[0][0] __________________________________________________________________________________________________ batch_normalization_12 (BatchNo (None, 40, 40, 64) 256 conv2d_transpose_5[0][0] __________________________________________________________________________________________________ up_sampling2d_5 (UpSampling2D) (None, 80, 80, 128) 0 add_4[0][0] __________________________________________________________________________________________________ up_sampling2d_4 (UpSampling2D) (None, 80, 80, 64) 0 batch_normalization_12[0][0] __________________________________________________________________________________________________ conv2d_6 (Conv2D) (None, 80, 80, 64) 8256 up_sampling2d_5[0][0] __________________________________________________________________________________________________ add_5 (Add) (None, 80, 80, 64) 0 up_sampling2d_4[0][0] conv2d_6[0][0] __________________________________________________________________________________________________ activation_13 (Activation) (None, 80, 80, 64) 0 add_5[0][0] __________________________________________________________________________________________________ conv2d_transpose_6 (Conv2DTrans (None, 80, 80, 32) 18464 activation_13[0][0] __________________________________________________________________________________________________ batch_normalization_13 (BatchNo (None, 80, 80, 32) 128 conv2d_transpose_6[0][0] __________________________________________________________________________________________________ activation_14 (Activation) (None, 80, 80, 32) 0 batch_normalization_13[0][0] __________________________________________________________________________________________________ conv2d_transpose_7 (Conv2DTrans (None, 80, 80, 32) 9248 activation_14[0][0] __________________________________________________________________________________________________ batch_normalization_14 (BatchNo (None, 80, 80, 32) 128 conv2d_transpose_7[0][0] __________________________________________________________________________________________________ up_sampling2d_7 (UpSampling2D) (None, 160, 160, 64) 0 add_5[0][0] __________________________________________________________________________________________________ up_sampling2d_6 (UpSampling2D) (None, 160, 160, 32) 0 batch_normalization_14[0][0] __________________________________________________________________________________________________ conv2d_7 (Conv2D) (None, 160, 160, 32) 2080 up_sampling2d_7[0][0] __________________________________________________________________________________________________ add_6 (Add) (None, 160, 160, 32) 0 up_sampling2d_6[0][0] conv2d_7[0][0] __________________________________________________________________________________________________ conv2d_8 (Conv2D) (None, 160, 160, 3) 867 add_6[0][0] ================================================================================================== Total params: 2,058,979 Trainable params: 2,055,203 Non-trainable params: 3,776 __________________________________________________________________________________________________ Set aside a validation split import random # Split our img paths into a training and a validation set val_samples = 1000 random.Random(1337).shuffle(input_img_paths) random.Random(1337).shuffle(target_img_paths) train_input_img_paths = input_img_paths[:-val_samples] train_target_img_paths = target_img_paths[:-val_samples] val_input_img_paths = input_img_paths[-val_samples:] val_target_img_paths = target_img_paths[-val_samples:] # Instantiate data Sequences for each split train_gen = OxfordPets( batch_size, img_size, train_input_img_paths, train_target_img_paths ) val_gen = OxfordPets(batch_size, img_size, val_input_img_paths, val_target_img_paths) Train the model # Configure the model for training. # We use the \"sparse\" version of categorical_crossentropy # because our target data is integers. model.compile(optimizer=\"rmsprop\", loss=\"sparse_categorical_crossentropy\") callbacks = [ keras.callbacks.ModelCheckpoint(\"oxford_segmentation.h5\", save_best_only=True) ] # Train the model, doing validation at the end of each epoch. epochs = 15 model.fit(train_gen, epochs=epochs, validation_data=val_gen, callbacks=callbacks) Epoch 1/15 2/199 [..............................] - ETA: 13s - loss: 5.4602WARNING:tensorflow:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0462s vs `on_train_batch_end` time: 0.0935s). Check your callbacks. 199/199 [==============================] - 32s 161ms/step - loss: 0.9396 - val_loss: 3.7159 Epoch 2/15 199/199 [==============================] - 32s 159ms/step - loss: 0.4911 - val_loss: 2.2709 Epoch 3/15 199/199 [==============================] - 32s 160ms/step - loss: 0.4205 - val_loss: 0.5184 Epoch 4/15 199/199 [==============================] - 32s 159ms/step - loss: 0.3739 - val_loss: 0.4584 Epoch 5/15 199/199 [==============================] - 32s 160ms/step - loss: 0.3416 - val_loss: 0.3968 Epoch 6/15 199/199 [==============================] - 32s 159ms/step - loss: 0.3131 - val_loss: 0.4059 Epoch 7/15 199/199 [==============================] - 31s 157ms/step - loss: 0.2895 - val_loss: 0.3963 Epoch 8/15 199/199 [==============================] - 31s 156ms/step - loss: 0.2695 - val_loss: 0.4035 Epoch 9/15 199/199 [==============================] - 31s 157ms/step - loss: 0.2528 - val_loss: 0.4184 Epoch 10/15 199/199 [==============================] - 31s 157ms/step - loss: 0.2360 - val_loss: 0.3950 Epoch 11/15 199/199 [==============================] - 31s 157ms/step - loss: 0.2247 - val_loss: 0.4139 Epoch 12/15 199/199 [==============================] - 31s 157ms/step - loss: 0.2126 - val_loss: 0.3861 Epoch 13/15 199/199 [==============================] - 31s 157ms/step - loss: 0.2026 - val_loss: 0.4138 Epoch 14/15 199/199 [==============================] - 31s 156ms/step - loss: 0.1932 - val_loss: 0.4265 Epoch 15/15 199/199 [==============================] - 31s 157ms/step - loss: 0.1857 - val_loss: 0.3959 Visualize predictions # Generate predictions for all images in the validation set val_gen = OxfordPets(batch_size, img_size, val_input_img_paths, val_target_img_paths) val_preds = model.predict(val_gen) def display_mask(i): \"\"\"Quick utility to display a model's prediction.\"\"\" mask = np.argmax(val_preds[i], axis=-1) mask = np.expand_dims(mask, axis=-1) img = PIL.ImageOps.autocontrast(keras.preprocessing.image.array_to_img(mask)) display(img) # Display results for validation image #10 i = 10 # Display input image display(Image(filename=val_input_img_paths[i])) # Display ground-truth target mask img = PIL.ImageOps.autocontrast(load_img(val_target_img_paths[i])) display(img) # Display mask predicted by our model display_mask(i) # Note that the model only sees inputs at 150x150. jpeg png png Similarity learning using a siamese network trained with a contrastive loss. Introduction Siamese Networks are neural networks which share weights between two or more sister networks, each producing embedding vectors of its respective inputs. In supervised similarity learning, the networks are then trained to maximize the contrast (distance) between embeddings of inputs of different classes, while minimizing the distance between embeddings of similar classes, resulting in embedding spaces that reflect the class segmentation of the training inputs. Setup import random import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import matplotlib.pyplot as plt Hyperparameters epochs = 10 batch_size = 16 margin = 1 # Margin for constrastive loss. Load the MNIST dataset (x_train_val, y_train_val), (x_test, y_test) = keras.datasets.mnist.load_data() # Change the data type to a floating point format x_train_val = x_train_val.astype(\"float32\") x_test = x_test.astype(\"float32\") Define training and validation sets # Keep 50% of train_val in validation set x_train, x_val = x_train_val[:30000], x_train_val[30000:] y_train, y_val = y_train_val[:30000], y_train_val[30000:] del x_train_val, y_train_val Create pairs of images We will train the model to differentiate between digits of different classes. For example, digit 0 needs to be differentiated from the rest of the digits (1 through 9), digit 1 - from 0 and 2 through 9, and so on. To carry this out, we will select N random images from class A (for example, for digit 0) and pair them with N random images from another class B (for example, for digit 1). Then, we can repeat this process for all classes of digits (until digit 9). Once we have paired digit 0 with other digits, we can repeat this process for the remaining classes for the rest of the digits (from 1 until 9). def make_pairs(x, y): \"\"\"Creates a tuple containing image pairs with corresponding label. Arguments: x: List containing images, each index in this list corresponds to one image. y: List containing labels, each label with datatype of `int`. Returns: Tuple containing two numpy arrays as (pairs_of_samples, labels), where pairs_of_samples' shape is (2len(x), 2,n_features_dims) and labels are a binary array of shape (2len(x)). \"\"\" num_classes = max(y) + 1 digit_indices = [np.where(y == i)[0] for i in range(num_classes)] pairs = [] labels = [] for idx1 in range(len(x)): # add a matching example x1 = x[idx1] label1 = y[idx1] idx2 = random.choice(digit_indices[label1]) x2 = x[idx2] pairs += [[x1, x2]] labels += [1] # add a non-matching example label2 = random.randint(0, num_classes - 1) while label2 == label1: label2 = random.randint(0, num_classes - 1) idx2 = random.choice(digit_indices[label2]) x2 = x[idx2] pairs += [[x1, x2]] labels += [0] return np.array(pairs), np.array(labels).astype(\"float32\") # make train pairs pairs_train, labels_train = make_pairs(x_train, y_train) # make validation pairs pairs_val, labels_val = make_pairs(x_val, y_val) # make test pairs pairs_test, labels_test = make_pairs(x_test, y_test) We get: pairs_train.shape = (60000, 2, 28, 28) We have 60,000 pairs Each pair contains 2 images Each image has shape (28, 28) Split the training pairs x_train_1 = pairs_train[:, 0] # x_train_1.shape is (60000, 28, 28) x_train_2 = pairs_train[:, 1] Split the validation pairs x_val_1 = pairs_val[:, 0] # x_val_1.shape = (60000, 28, 28) x_val_2 = pairs_val[:, 1] Split the test pairs x_test_1 = pairs_test[:, 0] # x_test_1.shape = (20000, 28, 28) x_test_2 = pairs_test[:, 1] Visualize pairs and their labels def visualize(pairs, labels, to_show=6, num_col=3, predictions=None, test=False): \"\"\"Creates a plot of pairs and labels, and prediction if it's test dataset. Arguments: pairs: Numpy Array, of pairs to visualize, having shape (Number of pairs, 2, 28, 28). to_show: Int, number of examples to visualize (default is 6) `to_show` must be an integral multiple of `num_col`. Otherwise it will be trimmed if it is greater than num_col, and incremented if if it is less then num_col. num_col: Int, number of images in one row - (default is 3) For test and train respectively, it should not exceed 3 and 7. predictions: Numpy Array of predictions with shape (to_show, 1) - (default is None) Must be passed when test=True. test: Boolean telling whether the dataset being visualized is train dataset or test dataset - (default False). Returns: None. \"\"\" # Define num_row # If to_show % num_col != 0 # trim to_show, # to trim to_show limit num_row to the point where # to_show % num_col == 0 # # If to_show//num_col == 0 # then it means num_col is greater then to_show # increment to_show # to increment to_show set num_row to 1 num_row = to_show // num_col if to_show // num_col != 0 else 1 # `to_show` must be an integral multiple of `num_col` # we found num_row and we have num_col # to increment or decrement to_show # to make it integral multiple of `num_col` # simply set it equal to num_row * num_col to_show = num_row * num_col # Plot the images fig, axes = plt.subplots(num_row, num_col, figsize=(5, 5)) for i in range(to_show): # If the number of rows is 1, the axes array is one-dimensional if num_row == 1: ax = axes[i % num_col] else: ax = axes[i // num_col, i % num_col] ax.imshow(tf.concat([pairs[i][0], pairs[i][1]], axis=1), cmap=\"gray\") ax.set_axis_off() if test: ax.set_title(\"True: {} | Pred: {:.5f}\".format(labels[i], predictions[i][0])) else: ax.set_title(\"Label: {}\".format(labels[i])) if test: plt.tight_layout(rect=(0, 0, 1.9, 1.9), w_pad=0.0) else: plt.tight_layout(rect=(0, 0, 1.5, 1.5)) plt.show() Inspect training pairs visualize(pairs_train[:-1], labels_train[:-1], to_show=4, num_col=4) png Inspect validation pairs visualize(pairs_val[:-1], labels_val[:-1], to_show=4, num_col=4) png Inspect test pairs visualize(pairs_test[:-1], labels_test[:-1], to_show=4, num_col=4) png Define the model There are be two input layers, each leading to its own network, which produces embeddings. A Lambda layer then merges them using an Euclidean distance and the merged output is fed to the final network. # Provided two tensors t1 and t2 # Euclidean distance = sqrt(sum(square(t1-t2))) def euclidean_distance(vects): \"\"\"Find the Euclidean distance between two vectors. Arguments: vects: List containing two tensors of same length. Returns: Tensor containing euclidean distance (as floating point value) between vectors. \"\"\" x, y = vects sum_square = tf.math.reduce_sum(tf.math.square(x - y), axis=1, keepdims=True) return tf.math.sqrt(tf.math.maximum(sum_square, tf.keras.backend.epsilon())) input = layers.Input((28, 28, 1)) x = tf.keras.layers.BatchNormalization()(input) x = layers.Conv2D(4, (5, 5), activation=\"tanh\")(x) x = layers.AveragePooling2D(pool_size=(2, 2))(x) x = layers.Conv2D(16, (5, 5), activation=\"tanh\")(x) x = layers.AveragePooling2D(pool_size=(2, 2))(x) x = layers.Flatten()(x) x = tf.keras.layers.BatchNormalization()(x) x = layers.Dense(10, activation=\"tanh\")(x) embedding_network = keras.Model(input, x) input_1 = layers.Input((28, 28, 1)) input_2 = layers.Input((28, 28, 1)) # As mentioned above, Siamese Network share weights between # tower networks (sister networks). To allow this, we will use # same embedding network for both tower networks. tower_1 = embedding_network(input_1) tower_2 = embedding_network(input_2) merge_layer = layers.Lambda(euclidean_distance)([tower_1, tower_2]) normal_layer = tf.keras.layers.BatchNormalization()(merge_layer) output_layer = layers.Dense(1, activation=\"sigmoid\")(normal_layer) siamese = keras.Model(inputs=[input_1, input_2], outputs=output_layer) Define the constrastive Loss def loss(margin=1): \"\"\"Provides 'constrastive_loss' an enclosing scope with variable 'margin'. Arguments: margin: Integer, defines the baseline for distance for which pairs should be classified as dissimilar. - (default is 1). Returns: 'constrastive_loss' function with data ('margin') attached. \"\"\" # Contrastive loss = mean( (1-true_value) * square(prediction) + # true_value * square( max(margin-prediction, 0) )) def contrastive_loss(y_true, y_pred): \"\"\"Calculates the constrastive loss. Arguments: y_true: List of labels, each label is of type float32. y_pred: List of predictions of same length as of y_true, each label is of type float32. Returns: A tensor containing constrastive loss as floating point value. \"\"\" square_pred = tf.math.square(y_pred) margin_square = tf.math.square(tf.math.maximum(margin - (y_pred), 0)) return tf.math.reduce_mean( (1 - y_true) * square_pred + (y_true) * margin_square ) return contrastive_loss Compile the model with the contrastive loss siamese.compile(loss=loss(margin=margin), optimizer=\"RMSprop\", metrics=[\"accuracy\"]) siamese.summary() Model: \"model_1\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_2 (InputLayer) [(None, 28, 28, 1)] 0 __________________________________________________________________________________________________ input_3 (InputLayer) [(None, 28, 28, 1)] 0 __________________________________________________________________________________________________ model (Functional) (None, 10) 5318 input_2[0][0] input_3[0][0] __________________________________________________________________________________________________ lambda (Lambda) (None, 1) 0 model[0][0] model[1][0] __________________________________________________________________________________________________ batch_normalization_2 (BatchNor (None, 1) 4 lambda[0][0] __________________________________________________________________________________________________ dense_1 (Dense) (None, 1) 2 batch_normalization_2[0][0] ================================================================================================== Total params: 5,324 Trainable params: 4,808 Non-trainable params: 516 __________________________________________________________________________________________________ Train the model history = siamese.fit( [x_train_1, x_train_2], labels_train, validation_data=([x_val_1, x_val_2], labels_val), batch_size=batch_size, epochs=epochs, ) Epoch 1/10 3750/3750 [==============================] - 25s 6ms/step - loss: 0.1993 - accuracy: 0.6626 - val_loss: 0.0525 - val_accuracy: 0.9331 Epoch 2/10 3750/3750 [==============================] - 23s 6ms/step - loss: 0.0611 - accuracy: 0.9187 - val_loss: 0.0277 - val_accuracy: 0.9644 Epoch 3/10 3750/3750 [==============================] - 24s 6ms/step - loss: 0.0455 - accuracy: 0.9409 - val_loss: 0.0214 - val_accuracy: 0.9719 Epoch 4/10 3750/3750 [==============================] - 27s 7ms/step - loss: 0.0386 - accuracy: 0.9506 - val_loss: 0.0198 - val_accuracy: 0.9743 Epoch 5/10 3750/3750 [==============================] - 45s 12ms/step - loss: 0.0362 - accuracy: 0.9529 - val_loss: 0.0169 - val_accuracy: 0.9783 Epoch 6/10 2497/3750 [==================>...........] - ETA: 10s - loss: 0.0343 - accuracy: 0.9552 Visualize results def plt_metric(history, metric, title, has_valid=True): \"\"\"Plots the given 'metric' from 'history'. Arguments: history: history attribute of History object returned from Model.fit. metric: Metric to plot, a string value present as key in 'history'. title: A string to be used as title of plot. has_valid: Boolean, true if valid data was passed to Model.fit else false. Returns: None. \"\"\" plt.plot(history[metric]) if has_valid: plt.plot(history[\"val_\" + metric]) plt.legend([\"train\", \"validation\"], loc=\"upper left\") plt.title(title) plt.ylabel(metric) plt.xlabel(\"epoch\") plt.show() # Plot the accuracy plt_metric(history=history.history, metric=\"accuracy\", title=\"Model accuracy\") # Plot the constrastive loss plt_metric(history=history.history, metric=\"loss\", title=\"Constrastive Loss\") png png Evaluate the model results = siamese.evaluate([x_test_1, x_test_2], labels_test) print(\"test loss, test acc:\", results) 625/625 [==============================] - 3s 4ms/step - loss: 0.0150 - accuracy: 0.9810 test loss, test acc: [0.015001337975263596, 0.9810000061988831] Visualize the predictions predictions = siamese.predict([x_test_1, x_test_2]) visualize(pairs_test, labels_test, to_show=3, predictions=predictions, test=True) png Training a Siamese Network to compare the similarity of images using a triplet loss function. Introduction A Siamese Network is a type of network architecture that contains two or more identical subnetworks used to generate feature vectors for each input and compare them. Siamese Networks can be applied to different use cases, like detecting duplicates, finding anomalies, and face recognition. This example uses a Siamese Network with three identical subnetworks. We will provide three images to the model, where two of them will be similar (anchor and positive samples), and the third will be unrelated (a negative example.) Our goal is for the model to learn to estimate the similarity between images. For the network to learn, we use a triplet loss function. You can find an introduction to triplet loss in the FaceNet paper by Schroff et al,. 2015. In this example, we define the triplet loss function as follows: L(A, P, N) = max(‖f(A) - f(P)‖² - ‖f(A) - f(N)‖² + margin, 0) This example uses the Totally Looks Like dataset by Rosenfeld et al., 2018. Setup import matplotlib.pyplot as plt import numpy as np import os import random import tensorflow as tf from pathlib import Path from tensorflow.keras import applications from tensorflow.keras import layers from tensorflow.keras import losses from tensorflow.keras import optimizers from tensorflow.keras import metrics from tensorflow.keras import Model from tensorflow.keras.applications import resnet target_shape = (200, 200) Load the dataset We are going to load the Totally Looks Like dataset and unzip it inside the ~/.keras directory in the local environment. The dataset consists of two separate files: left.zip contains the images that we will use as the anchor. right.zip contains the images that we will use as the positive sample (an image that looks like the anchor). cache_dir = Path(Path.home()) / \".keras\" anchor_images_path = cache_dir / \"left\" positive_images_path = cache_dir / \"right\" !gdown --id 1jvkbTr_giSP3Ru8OwGNCg6B4PvVbcO34 !gdown --id 1EzBZUb_mh_Dp_FKD0P4XiYYSd0QBH5zW !unzip -oq left.zip -d $cache_dir !unzip -oq right.zip -d $cache_dir zsh:1: command not found: gdown zsh:1: command not found: gdown unzip: cannot find or open left.zip, left.zip.zip or left.zip.ZIP. unzip: cannot find or open right.zip, right.zip.zip or right.zip.ZIP. Preparing the data We are going to use a tf.data pipeline to load the data and generate the triplets that we need to train the Siamese network. We'll set up the pipeline using a zipped list with anchor, positive, and negative filenames as the source. The pipeline will load and preprocess the corresponding images. def preprocess_image(filename): \"\"\" Load the specified file as a JPEG image, preprocess it and resize it to the target shape. \"\"\" image_string = tf.io.read_file(filename) image = tf.image.decode_jpeg(image_string, channels=3) image = tf.image.convert_image_dtype(image, tf.float32) image = tf.image.resize(image, target_shape) return image def preprocess_triplets(anchor, positive, negative): \"\"\" Given the filenames corresponding to the three images, load and preprocess them. \"\"\" return ( preprocess_image(anchor), preprocess_image(positive), preprocess_image(negative), ) Let's setup our data pipeline using a zipped list with an anchor, positive, and negative image filename as the source. The output of the pipeline contains the same triplet with every image loaded and preprocessed. # We need to make sure both the anchor and positive images are loaded in # sorted order so we can match them together. anchor_images = sorted( [str(anchor_images_path / f) for f in os.listdir(anchor_images_path)] ) positive_images = sorted( [str(positive_images_path / f) for f in os.listdir(positive_images_path)] ) image_count = len(anchor_images) anchor_dataset = tf.data.Dataset.from_tensor_slices(anchor_images) positive_dataset = tf.data.Dataset.from_tensor_slices(positive_images) # To generate the list of negative images, let's randomize the list of # available images and concatenate them together. rng = np.random.RandomState(seed=42) rng.shuffle(anchor_images) rng.shuffle(positive_images) negative_images = anchor_images + positive_images np.random.RandomState(seed=32).shuffle(negative_images) negative_dataset = tf.data.Dataset.from_tensor_slices(negative_images) negative_dataset = negative_dataset.shuffle(buffer_size=4096) dataset = tf.data.Dataset.zip((anchor_dataset, positive_dataset, negative_dataset)) dataset = dataset.shuffle(buffer_size=1024) dataset = dataset.map(preprocess_triplets) # Let's now split our dataset in train and validation. train_dataset = dataset.take(round(image_count * 0.8)) val_dataset = dataset.skip(round(image_count * 0.8)) train_dataset = train_dataset.batch(32, drop_remainder=False) train_dataset = train_dataset.prefetch(8) val_dataset = val_dataset.batch(32, drop_remainder=False) val_dataset = val_dataset.prefetch(8) Let's take a look at a few examples of triplets. Notice how the first two images look alike while the third one is always different. def visualize(anchor, positive, negative): \"\"\"Visualize a few triplets from the supplied batches.\"\"\" def show(ax, image): ax.imshow(image) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) fig = plt.figure(figsize=(9, 9)) axs = fig.subplots(3, 3) for i in range(3): show(axs[i, 0], anchor[i]) show(axs[i, 1], positive[i]) show(axs[i, 2], negative[i]) visualize(*list(train_dataset.take(1).as_numpy_iterator())[0]) png Setting up the embedding generator model Our Siamese Network will generate embeddings for each of the images of the triplet. To do this, we will use a ResNet50 model pretrained on ImageNet and connect a few Dense layers to it so we can learn to separate these embeddings. We will freeze the weights of all the layers of the model up until the layer conv5_block1_out. This is important to avoid affecting the weights that the model has already learned. We are going to leave the bottom few layers trainable, so that we can fine-tune their weights during training. base_cnn = resnet.ResNet50( weights=\"imagenet\", input_shape=target_shape + (3,), include_top=False ) flatten = layers.Flatten()(base_cnn.output) dense1 = layers.Dense(512, activation=\"relu\")(flatten) dense1 = layers.BatchNormalization()(dense1) dense2 = layers.Dense(256, activation=\"relu\")(dense1) dense2 = layers.BatchNormalization()(dense2) output = layers.Dense(256)(dense2) embedding = Model(base_cnn.input, output, name=\"Embedding\") trainable = False for layer in base_cnn.layers: if layer.name == \"conv5_block1_out\": trainable = True layer.trainable = trainable Setting up the Siamese Network model The Siamese network will receive each of the triplet images as an input, generate the embeddings, and output the distance between the anchor and the positive embedding, as well as the distance between the anchor and the negative embedding. To compute the distance, we can use a custom layer DistanceLayer that returns both values as a tuple. class DistanceLayer(layers.Layer): \"\"\" This layer is responsible for computing the distance between the anchor embedding and the positive embedding, and the anchor embedding and the negative embedding. \"\"\" def __init__(self, **kwargs): super().__init__(**kwargs) def call(self, anchor, positive, negative): ap_distance = tf.reduce_sum(tf.square(anchor - positive), -1) an_distance = tf.reduce_sum(tf.square(anchor - negative), -1) return (ap_distance, an_distance) anchor_input = layers.Input(name=\"anchor\", shape=target_shape + (3,)) positive_input = layers.Input(name=\"positive\", shape=target_shape + (3,)) negative_input = layers.Input(name=\"negative\", shape=target_shape + (3,)) distances = DistanceLayer()( embedding(resnet.preprocess_input(anchor_input)), embedding(resnet.preprocess_input(positive_input)), embedding(resnet.preprocess_input(negative_input)), ) siamese_network = Model( inputs=[anchor_input, positive_input, negative_input], outputs=distances ) Putting everything together We now need to implement a model with custom training loop so we can compute the triplet loss using the three embeddings produced by the Siamese network. Let's create a Mean metric instance to track the loss of the training process. class SiameseModel(Model): \"\"\"The Siamese Network model with a custom training and testing loops. Computes the triplet loss using the three embeddings produced by the Siamese Network. The triplet loss is defined as: L(A, P, N) = max(‖f(A) - f(P)‖² - ‖f(A) - f(N)‖² + margin, 0) \"\"\" def __init__(self, siamese_network, margin=0.5): super(SiameseModel, self).__init__() self.siamese_network = siamese_network self.margin = margin self.loss_tracker = metrics.Mean(name=\"loss\") def call(self, inputs): return self.siamese_network(inputs) def train_step(self, data): # GradientTape is a context manager that records every operation that # you do inside. We are using it here to compute the loss so we can get # the gradients and apply them using the optimizer specified in # `compile()`. with tf.GradientTape() as tape: loss = self._compute_loss(data) # Storing the gradients of the loss function with respect to the # weights/parameters. gradients = tape.gradient(loss, self.siamese_network.trainable_weights) # Applying the gradients on the model using the specified optimizer self.optimizer.apply_gradients( zip(gradients, self.siamese_network.trainable_weights) ) # Let's update and return the training loss metric. self.loss_tracker.update_state(loss) return {\"loss\": self.loss_tracker.result()} def test_step(self, data): loss = self._compute_loss(data) # Let's update and return the loss metric. self.loss_tracker.update_state(loss) return {\"loss\": self.loss_tracker.result()} def _compute_loss(self, data): # The output of the network is a tuple containing the distances # between the anchor and the positive example, and the anchor and # the negative example. ap_distance, an_distance = self.siamese_network(data) # Computing the Triplet Loss by subtracting both distances and # making sure we don't get a negative value. loss = ap_distance - an_distance loss = tf.maximum(loss + self.margin, 0.0) return loss @property def metrics(self): # We need to list our metrics here so the `reset_states()` can be # called automatically. return [self.loss_tracker] Training We are now ready to train our model. siamese_model = SiameseModel(siamese_network) siamese_model.compile(optimizer=optimizers.Adam(0.0001)) siamese_model.fit(train_dataset, epochs=10, validation_data=val_dataset) Epoch 1/10 151/151 [==============================] - 277s 2s/step - loss: 0.5014 - val_loss: 0.3719 Epoch 2/10 151/151 [==============================] - 276s 2s/step - loss: 0.3884 - val_loss: 0.3632 Epoch 3/10 151/151 [==============================] - 287s 2s/step - loss: 0.3711 - val_loss: 0.3509 Epoch 4/10 151/151 [==============================] - 295s 2s/step - loss: 0.3585 - val_loss: 0.3287 Epoch 5/10 151/151 [==============================] - 299s 2s/step - loss: 0.3420 - val_loss: 0.3301 Epoch 6/10 151/151 [==============================] - 297s 2s/step - loss: 0.3181 - val_loss: 0.3419 Epoch 7/10 151/151 [==============================] - 290s 2s/step - loss: 0.3131 - val_loss: 0.3201 Epoch 8/10 151/151 [==============================] - 295s 2s/step - loss: 0.3102 - val_loss: 0.3152 Epoch 9/10 151/151 [==============================] - 286s 2s/step - loss: 0.2905 - val_loss: 0.2937 Epoch 10/10 151/151 [==============================] - 270s 2s/step - loss: 0.2921 - val_loss: 0.2952 Inspecting what the network has learned At this point, we can check how the network learned to separate the embeddings depending on whether they belong to similar images. We can use cosine similarity to measure the similarity between embeddings. Let's pick a sample from the dataset to check the similarity between the embeddings generated for each image. sample = next(iter(train_dataset)) visualize(*sample) anchor, positive, negative = sample anchor_embedding, positive_embedding, negative_embedding = ( embedding(resnet.preprocess_input(anchor)), embedding(resnet.preprocess_input(positive)), embedding(resnet.preprocess_input(negative)), ) png Finally, we can compute the cosine similarity between the anchor and positive images and compare it with the similarity between the anchor and the negative images. We should expect the similarity between the anchor and positive images to be larger than the similarity between the anchor and the negative images. cosine_similarity = metrics.CosineSimilarity() positive_similarity = cosine_similarity(anchor_embedding, positive_embedding) print(\"Positive similarity:\", positive_similarity.numpy()) negative_similarity = cosine_similarity(anchor_embedding, negative_embedding) print(\"Negative similarity\", negative_similarity.numpy()) Positive similarity: 0.9940324 Negative similarity 0.9918252 Summary The tf.data API enables you to build efficient input pipelines for your model. It is particularly useful if you have a large dataset. You can learn more about tf.data pipelines in tf.data: Build TensorFlow input pipelines. In this example, we use a pre-trained ResNet50 as part of the subnetwork that generates the feature embeddings. By using transfer learning, Implementing Super-Resolution using Efficient sub-pixel model on BSDS500. Introduction ESPCN (Efficient Sub-Pixel CNN), proposed by Shi, 2016 is a model that reconstructs a high-resolution version of an image given a low-resolution version. It leverages efficient \"sub-pixel convolution\" layers, which learns an array of image upscaling filters. In this code example, we will implement the model from the paper and train it on a small dataset, BSDS500. Setup import tensorflow as tf import os import math import numpy as np from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.preprocessing.image import load_img from tensorflow.keras.preprocessing.image import array_to_img from tensorflow.keras.preprocessing.image import img_to_array from tensorflow.keras.preprocessing import image_dataset_from_directory from IPython.display import display Load data: BSDS500 dataset Download dataset We use the built-in keras.utils.get_file utility to retrieve the dataset. dataset_url = \"http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/BSR/BSR_bsds500.tgz\" data_dir = keras.utils.get_file(origin=dataset_url, fname=\"BSR\", untar=True) root_dir = os.path.join(data_dir, \"BSDS500/data\") We create training and validation datasets via image_dataset_from_directory. crop_size = 300 upscale_factor = 3 input_size = crop_size // upscale_factor batch_size = 8 train_ds = image_dataset_from_directory( root_dir, batch_size=batch_size, image_size=(crop_size, crop_size), validation_split=0.2, subset=\"training\", seed=1337, label_mode=None, ) valid_ds = image_dataset_from_directory( root_dir, batch_size=batch_size, image_size=(crop_size, crop_size), validation_split=0.2, subset=\"validation\", seed=1337, label_mode=None, ) Found 500 files belonging to 2 classes. Using 400 files for training. Found 500 files belonging to 2 classes. Using 100 files for validation. We rescale the images to take values in the range [0, 1]. def scaling(input_image): input_image = input_image / 255.0 return input_image # Scale from (0, 255) to (0, 1) train_ds = train_ds.map(scaling) valid_ds = valid_ds.map(scaling) Let's visualize a few sample images: for batch in train_ds.take(1): for img in batch: display(array_to_img(img)) png png png png png png png png We prepare a dataset of test image paths that we will use for visual evaluation at the end of this example. dataset = os.path.join(root_dir, \"images\") test_path = os.path.join(dataset, \"test\") test_img_paths = sorted( [ os.path.join(test_path, fname) for fname in os.listdir(test_path) if fname.endswith(\".jpg\") ] ) Crop and resize images Let's process image data. First, we convert our images from the RGB color space to the YUV colour space. For the input data (low-resolution images), we crop the image, retrieve the y channel (luninance), and resize it with the area method (use BICUBIC if you use PIL). We only consider the luminance channel in the YUV color space because humans are more sensitive to luminance change. For the target data (high-resolution images), we just crop the image and retrieve the y channel. # Use TF Ops to process. def process_input(input, input_size, upscale_factor): input = tf.image.rgb_to_yuv(input) last_dimension_axis = len(input.shape) - 1 y, u, v = tf.split(input, 3, axis=last_dimension_axis) return tf.image.resize(y, [input_size, input_size], method=\"area\") def process_target(input): input = tf.image.rgb_to_yuv(input) last_dimension_axis = len(input.shape) - 1 y, u, v = tf.split(input, 3, axis=last_dimension_axis) return y train_ds = train_ds.map( lambda x: (process_input(x, input_size, upscale_factor), process_target(x)) ) train_ds = train_ds.prefetch(buffer_size=32) valid_ds = valid_ds.map( lambda x: (process_input(x, input_size, upscale_factor), process_target(x)) ) valid_ds = valid_ds.prefetch(buffer_size=32) Let's take a look at the input and target data. for batch in train_ds.take(1): for img in batch[0]: display(array_to_img(img)) for img in batch[1]: display(array_to_img(img)) png png png png png png png png png png png png png png png png Build a model Compared to the paper, we add one more layer and we use the relu activation function instead of tanh. It achieves better performance even though we train the model for fewer epochs. def get_model(upscale_factor=3, channels=1): conv_args = { \"activation\": \"relu\", \"kernel_initializer\": \"Orthogonal\", \"padding\": \"same\", } inputs = keras.Input(shape=(None, None, channels)) x = layers.Conv2D(64, 5, **conv_args)(inputs) x = layers.Conv2D(64, 3, **conv_args)(x) x = layers.Conv2D(32, 3, **conv_args)(x) x = layers.Conv2D(channels * (upscale_factor ** 2), 3, **conv_args)(x) outputs = tf.nn.depth_to_space(x, upscale_factor) return keras.Model(inputs, outputs) Define utility functions We need to define several utility functions to monitor our results: plot_results to plot an save an image. get_lowres_image to convert an image to its low-resolution version. upscale_image to turn a low-resolution image to a high-resolution version reconstructed by the model. In this function, we use the y channel from the YUV color space as input to the model and then combine the output with the other channels to obtain an RGB image. import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1.inset_locator import zoomed_inset_axes from mpl_toolkits.axes_grid1.inset_locator import mark_inset import PIL def plot_results(img, prefix, title): \"\"\"Plot the result with zoom-in area.\"\"\" img_array = img_to_array(img) img_array = img_array.astype(\"float32\") / 255.0 # Create a new figure with a default 111 subplot. fig, ax = plt.subplots() im = ax.imshow(img_array[::-1], origin=\"lower\") plt.title(title) # zoom-factor: 2.0, location: upper-left axins = zoomed_inset_axes(ax, 2, loc=2) axins.imshow(img_array[::-1], origin=\"lower\") # Specify the limits. x1, x2, y1, y2 = 200, 300, 100, 200 # Apply the x-limits. axins.set_xlim(x1, x2) # Apply the y-limits. axins.set_ylim(y1, y2) plt.yticks(visible=False) plt.xticks(visible=False) # Make the line. mark_inset(ax, axins, loc1=1, loc2=3, fc=\"none\", ec=\"blue\") plt.savefig(str(prefix) + \"-\" + title + \".png\") plt.show() def get_lowres_image(img, upscale_factor): \"\"\"Return low-resolution image to use as model input.\"\"\" return img.resize( (img.size[0] // upscale_factor, img.size[1] // upscale_factor), PIL.Image.BICUBIC, ) def upscale_image(model, img): \"\"\"Predict the result based on input image and restore the image as RGB.\"\"\" ycbcr = img.convert(\"YCbCr\") y, cb, cr = ycbcr.split() y = img_to_array(y) y = y.astype(\"float32\") / 255.0 input = np.expand_dims(y, axis=0) out = model.predict(input) out_img_y = out[0] out_img_y *= 255.0 # Restore the image in RGB color space. out_img_y = out_img_y.clip(0, 255) out_img_y = out_img_y.reshape((np.shape(out_img_y)[0], np.shape(out_img_y)[1])) out_img_y = PIL.Image.fromarray(np.uint8(out_img_y), mode=\"L\") out_img_cb = cb.resize(out_img_y.size, PIL.Image.BICUBIC) out_img_cr = cr.resize(out_img_y.size, PIL.Image.BICUBIC) out_img = PIL.Image.merge(\"YCbCr\", (out_img_y, out_img_cb, out_img_cr)).convert( \"RGB\" ) return out_img Define callbacks to monitor training The ESPCNCallback object will compute and display the PSNR metric. This is the main metric we use to evaluate super-resolution performance. class ESPCNCallback(keras.callbacks.Callback): def __init__(self): super(ESPCNCallback, self).__init__() self.test_img = get_lowres_image(load_img(test_img_paths[0]), upscale_factor) # Store PSNR value in each epoch. def on_epoch_begin(self, epoch, logs=None): self.psnr = [] def on_epoch_end(self, epoch, logs=None): print(\"Mean PSNR for epoch: %.2f\" % (np.mean(self.psnr))) if epoch % 20 == 0: prediction = upscale_image(self.model, self.test_img) plot_results(prediction, \"epoch-\" + str(epoch), \"prediction\") def on_test_batch_end(self, batch, logs=None): self.psnr.append(10 * math.log10(1 / logs[\"loss\"])) Define ModelCheckpoint and EarlyStopping callbacks. early_stopping_callback = keras.callbacks.EarlyStopping(monitor=\"loss\", patience=10) checkpoint_filepath = \"/tmp/checkpoint\" model_checkpoint_callback = keras.callbacks.ModelCheckpoint( filepath=checkpoint_filepath, save_weights_only=True, monitor=\"loss\", mode=\"min\", save_best_only=True, ) model = get_model(upscale_factor=upscale_factor, channels=1) model.summary() callbacks = [ESPCNCallback(), early_stopping_callback, model_checkpoint_callback] loss_fn = keras.losses.MeanSquaredError() optimizer = keras.optimizers.Adam(learning_rate=0.001) Model: \"model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, None, None, 1)] 0 _________________________________________________________________ conv2d (Conv2D) (None, None, None, 64) 1664 _________________________________________________________________ conv2d_1 (Conv2D) (None, None, None, 64) 36928 _________________________________________________________________ conv2d_2 (Conv2D) (None, None, None, 32) 18464 _________________________________________________________________ conv2d_3 (Conv2D) (None, None, None, 9) 2601 _________________________________________________________________ tf.nn.depth_to_space (TFOpLa (None, None, None, 1) 0 ================================================================= Total params: 59,657 Trainable params: 59,657 Non-trainable params: 0 _________________________________________________________________ Train the model epochs = 100 model.compile( optimizer=optimizer, loss=loss_fn, ) model.fit( train_ds, epochs=epochs, callbacks=callbacks, validation_data=valid_ds, verbose=2 ) # The model weights (that are considered the best) are loaded into the model. model.load_weights(checkpoint_filepath) WARNING: Logging before flag parsing goes to stderr. W0828 11:01:31.262773 4528061888 callbacks.py:1270] Automatic model reloading for interrupted job was removed from the `ModelCheckpoint` callback in multi-worker mode, please use the [`keras.callbacks.experimental.BackupAndRestore`](/api/callbacks/backup_and_restore#backupandrestore-class) callback instead. See this tutorial for details: https://www.tensorflow.org/tutorials/distribute/multi_worker_with_keras#backupandrestore_callback. Epoch 1/100 Mean PSNR for epoch: 22.03 png 50/50 - 14s - loss: 0.0259 - val_loss: 0.0063 Epoch 2/100 Mean PSNR for epoch: 24.55 50/50 - 13s - loss: 0.0049 - val_loss: 0.0034 Epoch 3/100 Mean PSNR for epoch: 25.57 50/50 - 13s - loss: 0.0035 - val_loss: 0.0029 Epoch 4/100 Mean PSNR for epoch: 26.35 50/50 - 13s - loss: 0.0031 - val_loss: 0.0026 Epoch 5/100 Mean PSNR for epoch: 25.88 50/50 - 13s - loss: 0.0029 - val_loss: 0.0026 Epoch 6/100 Mean PSNR for epoch: 26.23 50/50 - 13s - loss: 0.0030 - val_loss: 0.0025 Epoch 7/100 Mean PSNR for epoch: 26.30 50/50 - 13s - loss: 0.0028 - val_loss: 0.0025 Epoch 8/100 Mean PSNR for epoch: 26.27 50/50 - 13s - loss: 0.0028 - val_loss: 0.0025 Epoch 9/100 Mean PSNR for epoch: 26.38 50/50 - 12s - loss: 0.0028 - val_loss: 0.0025 Epoch 10/100 Mean PSNR for epoch: 26.25 50/50 - 12s - loss: 0.0027 - val_loss: 0.0024 Epoch 11/100 Mean PSNR for epoch: 26.19 50/50 - 12s - loss: 0.0027 - val_loss: 0.0025 Epoch 12/100 Mean PSNR for epoch: 25.97 50/50 - 12s - loss: 0.0028 - val_loss: 0.0025 Epoch 13/100 Mean PSNR for epoch: 26.30 50/50 - 12s - loss: 0.0027 - val_loss: 0.0024 Epoch 14/100 Mean PSNR for epoch: 26.43 50/50 - 12s - loss: 0.0027 - val_loss: 0.0024 Epoch 15/100 Mean PSNR for epoch: 26.49 50/50 - 12s - loss: 0.0027 - val_loss: 0.0024 Epoch 16/100 Mean PSNR for epoch: 26.41 50/50 - 12s - loss: 0.0027 - val_loss: 0.0024 Epoch 17/100 Mean PSNR for epoch: 25.86 50/50 - 13s - loss: 0.0027 - val_loss: 0.0024 Epoch 18/100 Mean PSNR for epoch: 26.11 50/50 - 12s - loss: 0.0027 - val_loss: 0.0025 Epoch 19/100 Mean PSNR for epoch: 26.78 50/50 - 12s - loss: 0.0027 - val_loss: 0.0024 Epoch 20/100 Mean PSNR for epoch: 26.59 50/50 - 12s - loss: 0.0027 - val_loss: 0.0024 Epoch 21/100 Mean PSNR for epoch: 26.52 png 50/50 - 13s - loss: 0.0026 - val_loss: 0.0024 Epoch 22/100 Mean PSNR for epoch: 26.21 50/50 - 13s - loss: 0.0026 - val_loss: 0.0024 Epoch 23/100 Mean PSNR for epoch: 26.32 50/50 - 13s - loss: 0.0031 - val_loss: 0.0025 Epoch 24/100 Mean PSNR for epoch: 26.68 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 25/100 Mean PSNR for epoch: 27.03 50/50 - 12s - loss: 0.0026 - val_loss: 0.0023 Epoch 26/100 Mean PSNR for epoch: 26.31 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 27/100 Mean PSNR for epoch: 27.20 50/50 - 12s - loss: 0.0026 - val_loss: 0.0023 Epoch 28/100 Mean PSNR for epoch: 26.53 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 29/100 Mean PSNR for epoch: 26.63 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 30/100 Mean PSNR for epoch: 26.43 50/50 - 12s - loss: 0.0026 - val_loss: 0.0023 Epoch 31/100 Mean PSNR for epoch: 26.13 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 32/100 Mean PSNR for epoch: 26.50 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 33/100 Mean PSNR for epoch: 26.91 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 34/100 Mean PSNR for epoch: 26.48 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 35/100 Mean PSNR for epoch: 26.68 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 36/100 Mean PSNR for epoch: 26.82 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 37/100 Mean PSNR for epoch: 26.53 50/50 - 14s - loss: 0.0026 - val_loss: 0.0023 Epoch 38/100 Mean PSNR for epoch: 26.73 50/50 - 14s - loss: 0.0026 - val_loss: 0.0023 Epoch 39/100 Mean PSNR for epoch: 26.07 50/50 - 13s - loss: 0.0026 - val_loss: 0.0026 Epoch 40/100 Mean PSNR for epoch: 26.36 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 41/100 Mean PSNR for epoch: 26.43 png 50/50 - 14s - loss: 0.0026 - val_loss: 0.0023 Epoch 42/100 Mean PSNR for epoch: 26.67 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 43/100 Mean PSNR for epoch: 26.83 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 44/100 Mean PSNR for epoch: 26.81 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 45/100 Mean PSNR for epoch: 26.45 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 46/100 Mean PSNR for epoch: 26.25 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 47/100 Mean PSNR for epoch: 26.56 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 48/100 Mean PSNR for epoch: 26.28 50/50 - 13s - loss: 0.0028 - val_loss: 0.0023 Epoch 49/100 Mean PSNR for epoch: 26.52 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 50/100 Mean PSNR for epoch: 26.41 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 51/100 Mean PSNR for epoch: 26.69 50/50 - 12s - loss: 0.0025 - val_loss: 0.0023 Epoch 52/100 Mean PSNR for epoch: 26.44 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 53/100 Mean PSNR for epoch: 26.90 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 54/100 Mean PSNR for epoch: 26.43 50/50 - 13s - loss: 0.0026 - val_loss: 0.0024 Epoch 55/100 Mean PSNR for epoch: 26.83 50/50 - 13s - loss: 0.0026 - val_loss: 0.0023 Epoch 56/100 Mean PSNR for epoch: 26.77 50/50 - 14s - loss: 0.0025 - val_loss: 0.0023 Epoch 57/100 Mean PSNR for epoch: 26.67 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 58/100 Mean PSNR for epoch: 26.45 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 59/100 Mean PSNR for epoch: 26.85 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 60/100 Mean PSNR for epoch: 26.41 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 61/100 Mean PSNR for epoch: 26.36 png 50/50 - 14s - loss: 0.0026 - val_loss: 0.0024 Epoch 62/100 Mean PSNR for epoch: 26.21 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 63/100 Mean PSNR for epoch: 26.36 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 64/100 Mean PSNR for epoch: 27.31 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 65/100 Mean PSNR for epoch: 26.88 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 66/100 Mean PSNR for epoch: 26.34 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 67/100 Mean PSNR for epoch: 26.65 50/50 - 13s - loss: 0.0025 - val_loss: 0.0023 Epoch 68/100 Mean PSNR for epoch: 24.88 50/50 - 13s - loss: 0.0030 - val_loss: 0.0034 Epoch 69/100 Mean PSNR for epoch: 26.41 50/50 - 13s - loss: 0.0027 - val_loss: 0.0023 Epoch 70/100 Mean PSNR for epoch: 26.71 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 71/100 Mean PSNR for epoch: 26.70 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 72/100 Mean PSNR for epoch: 26.88 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 73/100 Mean PSNR for epoch: 26.72 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 74/100 Mean PSNR for epoch: 26.53 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 75/100 Mean PSNR for epoch: 26.85 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 76/100 Mean PSNR for epoch: 26.53 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 77/100 Mean PSNR for epoch: 26.50 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 78/100 Mean PSNR for epoch: 26.90 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 79/100 Mean PSNR for epoch: 26.92 50/50 - 15s - loss: 0.0025 - val_loss: 0.0022 Epoch 80/100 Mean PSNR for epoch: 27.00 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 81/100 Mean PSNR for epoch: 26.89 png 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 82/100 Mean PSNR for epoch: 26.62 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 83/100 Mean PSNR for epoch: 26.85 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 84/100 Mean PSNR for epoch: 26.69 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 85/100 Mean PSNR for epoch: 26.81 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 86/100 Mean PSNR for epoch: 26.16 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 87/100 Mean PSNR for epoch: 26.48 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 88/100 Mean PSNR for epoch: 25.62 50/50 - 14s - loss: 0.0026 - val_loss: 0.0027 Epoch 89/100 Mean PSNR for epoch: 26.55 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 90/100 Mean PSNR for epoch: 26.20 50/50 - 14s - loss: 0.0025 - val_loss: 0.0023 Epoch 91/100 Mean PSNR for epoch: 26.35 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 92/100 Mean PSNR for epoch: 26.85 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 93/100 Mean PSNR for epoch: 26.83 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 94/100 Mean PSNR for epoch: 26.63 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 95/100 Mean PSNR for epoch: 25.94 50/50 - 13s - loss: 0.0025 - val_loss: 0.0024 Epoch 96/100 Mean PSNR for epoch: 26.47 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 97/100 Mean PSNR for epoch: 26.42 50/50 - 14s - loss: 0.0025 - val_loss: 0.0022 Epoch 98/100 Mean PSNR for epoch: 26.33 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 99/100 Mean PSNR for epoch: 26.55 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Epoch 100/100 Mean PSNR for epoch: 27.08 50/50 - 13s - loss: 0.0025 - val_loss: 0.0022 Run model prediction and plot the results Let's compute the reconstructed version of a few images and save the results. total_bicubic_psnr = 0.0 total_test_psnr = 0.0 for index, test_img_path in enumerate(test_img_paths[50:60]): img = load_img(test_img_path) lowres_input = get_lowres_image(img, upscale_factor) w = lowres_input.size[0] * upscale_factor h = lowres_input.size[1] * upscale_factor highres_img = img.resize((w, h)) prediction = upscale_image(model, lowres_input) lowres_img = lowres_input.resize((w, h)) lowres_img_arr = img_to_array(lowres_img) highres_img_arr = img_to_array(highres_img) predict_img_arr = img_to_array(prediction) bicubic_psnr = tf.image.psnr(lowres_img_arr, highres_img_arr, max_val=255) test_psnr = tf.image.psnr(predict_img_arr, highres_img_arr, max_val=255) total_bicubic_psnr += bicubic_psnr total_test_psnr += test_psnr print( \"PSNR of low resolution image and high resolution image is %.4f\" % bicubic_psnr ) print(\"PSNR of predict and high resolution is %.4f\" % test_psnr) plot_results(lowres_img, index, \"lowres\") plot_results(highres_img, index, \"highres\") plot_results(prediction, index, \"prediction\") print(\"Avg. PSNR of lowres images is %.4f\" % (total_bicubic_psnr / 10)) print(\"Avg. PSNR of reconstructions is %.4f\" % (total_test_psnr / 10)) PSNR of low resolution image and high resolution image is 28.2682 PSNR of predict and high resolution is 29.7881 png png png PSNR of low resolution image and high resolution image is 23.0465 PSNR of predict and high resolution is 25.1304 png png png PSNR of low resolution image and high resolution image is 25.4113 PSNR of predict and high resolution is 27.3936 png png png PSNR of low resolution image and high resolution image is 26.5175 PSNR of predict and high resolution is 27.1014 png png png PSNR of low resolution image and high resolution image is 24.2559 PSNR of predict and high resolution is 25.7635 png png png PSNR of low resolution image and high resolution image is 23.9661 PSNR of predict and high resolution is 25.9522 png png png PSNR of low resolution image and high resolution image is 24.3061 PSNR of predict and high resolution is 26.3963 png png png PSNR of low resolution image and high resolution image is 21.7309 PSNR of predict and high resolution is 23.8342 png png png PSNR of low resolution image and high resolution image is 28.8549 PSNR of predict and high resolution is 29.6143 png png png PSNR of low resolution image and high resolution image is 23.9198 PSNR of predict and high resolution is 25.2592 png png png Avg. PSNR of lowres images is 25.0277 Avg. PSNR of reconstructions is 26.6233 Deep dive into location-specific and channel-agnostic involution kernels. Introduction Convolution has been the basis of most modern neural networks for computer vision. A convolution kernel is spatial-agnostic and channel-specific. Because of this, it isn't able to adapt to different visual patterns with respect to different spatial locations. Along with location-related problems, the receptive field of convolution creates challenges with regard to capturing long-range spatial interactions. To address the above issues, Li et. al. rethink the properties of convolution in Involution: Inverting the Inherence of Convolution for VisualRecognition. The authors propose the \"involution kernel\", that is location-specific and channel-agnostic. Due to the location-specific nature of the operation, the authors say that self-attention falls under the design paradigm of involution. This example describes the involution kernel, compares two image classification models, one with convolution and the other with involution, and also tries drawing a parallel with the self-attention layer. Setup import tensorflow as tf from tensorflow import keras import matplotlib.pyplot as plt # Set seed for reproducibility. tf.random.set_seed(42) Convolution Convolution remains the mainstay of deep neural networks for computer vision. To understand Involution, it is necessary to talk about the convolution operation. Imgur Consider an input tensor X with dimensions H, W and C_in. We take a collection of C_out convolution kernels each of shape K, K, C_in. With the multiply-add operation between the input tensor and the kernels we obtain an output tensor Y with dimensions H, W, C_out. In the diagram above C_out=3. This makes the output tensor of shape H, W and 3. One can notice that the convoltuion kernel does not depend on the spatial position of the input tensor which makes it location-agnostic. On the other hand, each channel in the output tensor is based on a specific convolution filter which makes is channel-specific. Involution The idea is to have an operation that is both location-specific and channel-agnostic. Trying to implement these specific properties poses a challenge. With a fixed number of involution kernels (for each spatial position) we will not be able to process variable-resolution input tensors. To solve this problem, the authors have considered generating each kernel conditioned on specific spatial positions. With this method, we should be able to process variable-resolution input tensors with ease. The diagram below provides an intuition on this kernel generation method. Imgur class Involution(keras.layers.Layer): def __init__( self, channel, group_number, kernel_size, stride, reduction_ratio, name ): super().__init__(name=name) # Initialize the parameters. self.channel = channel self.group_number = group_number self.kernel_size = kernel_size self.stride = stride self.reduction_ratio = reduction_ratio def build(self, input_shape): # Get the shape of the input. (_, height, width, num_channels) = input_shape # Scale the height and width with respect to the strides. height = height // self.stride width = width // self.stride # Define a layer that average pools the input tensor # if stride is more than 1. self.stride_layer = ( keras.layers.AveragePooling2D( pool_size=self.stride, strides=self.stride, padding=\"same\" ) if self.stride > 1 else tf.identity ) # Define the kernel generation layer. self.kernel_gen = keras.Sequential( [ keras.layers.Conv2D( filters=self.channel // self.reduction_ratio, kernel_size=1 ), keras.layers.BatchNormalization(), keras.layers.ReLU(), keras.layers.Conv2D( filters=self.kernel_size * self.kernel_size * self.group_number, kernel_size=1, ), ] ) # Define reshape layers self.kernel_reshape = keras.layers.Reshape( target_shape=( height, width, self.kernel_size * self.kernel_size, 1, self.group_number, ) ) self.input_patches_reshape = keras.layers.Reshape( target_shape=( height, width, self.kernel_size * self.kernel_size, num_channels // self.group_number, self.group_number, ) ) self.output_reshape = keras.layers.Reshape( target_shape=(height, width, num_channels) ) def call(self, x): # Generate the kernel with respect to the input tensor. # B, H, W, K*K*G kernel_input = self.stride_layer(x) kernel = self.kernel_gen(kernel_input) # reshape the kerenl # B, H, W, K*K, 1, G kernel = self.kernel_reshape(kernel) # Extract input patches. # B, H, W, K*K*C input_patches = tf.image.extract_patches( images=x, sizes=[1, self.kernel_size, self.kernel_size, 1], strides=[1, self.stride, self.stride, 1], rates=[1, 1, 1, 1], padding=\"SAME\", ) # Reshape the input patches to align with later operations. # B, H, W, K*K, C//G, G input_patches = self.input_patches_reshape(input_patches) # Compute the multiply-add operation of kernels and patches. # B, H, W, K*K, C//G, G output = tf.multiply(kernel, input_patches) # B, H, W, C//G, G output = tf.reduce_sum(output, axis=3) # Reshape the output kernel. # B, H, W, C output = self.output_reshape(output) # Return the output tensor and the kernel. return output, kernel Testing the Involution layer # Define the input tensor. input_tensor = tf.random.normal((32, 256, 256, 3)) # Compute involution with stride 1. output_tensor, _ = Involution( channel=3, group_number=1, kernel_size=5, stride=1, reduction_ratio=1, name=\"inv_1\" )(input_tensor) print(f\"with stride 1 ouput shape: {output_tensor.shape}\") # Compute involution with stride 2. output_tensor, _ = Involution( channel=3, group_number=1, kernel_size=5, stride=2, reduction_ratio=1, name=\"inv_2\" )(input_tensor) print(f\"with stride 2 ouput shape: {output_tensor.shape}\") # Compute involution with stride 1, channel 16 and reduction ratio 2. output_tensor, _ = Involution( channel=16, group_number=1, kernel_size=5, stride=1, reduction_ratio=2, name=\"inv_3\" )(input_tensor) print( \"with channel 16 and reduction ratio 2 ouput shape: {}\".format(output_tensor.shape) ) with stride 1 ouput shape: (32, 256, 256, 3) with stride 2 ouput shape: (32, 128, 128, 3) with channel 16 and reduction ratio 2 ouput shape: (32, 256, 256, 3) Image Classification In this section, we will build an image-classifier model. There will be two models one with convolutions and the other with involutions. The image-classification model is heavily inspired by this Convolutional Neural Network (CNN) tutorial from Google. Get the CIFAR10 Dataset # Load the CIFAR10 dataset. print(\"loading the CIFAR10 dataset...\") (train_images, train_labels), ( test_images, test_labels, ) = keras.datasets.cifar10.load_data() # Normalize pixel values to be between 0 and 1. (train_images, test_images) = (train_images / 255.0, test_images / 255.0) # Shuffle and batch the dataset. train_ds = ( tf.data.Dataset.from_tensor_slices((train_images, train_labels)) .shuffle(256) .batch(256) ) test_ds = tf.data.Dataset.from_tensor_slices((test_images, test_labels)).batch(256) loading the CIFAR10 dataset... Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz 170500096/170498071 [==============================] - 3s 0us/step Visualise the data class_names = [ \"airplane\", \"automobile\", \"bird\", \"cat\", \"deer\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\", ] plt.figure(figsize=(10, 10)) for i in range(25): plt.subplot(5, 5, i + 1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(train_images[i]) plt.xlabel(class_names[train_labels[i][0]]) plt.show() png Convolutional Neural Network # Build the conv model. print(\"building the convolution model...\") conv_model = keras.Sequential( [ keras.layers.Conv2D(32, (3, 3), input_shape=(32, 32, 3), padding=\"same\"), keras.layers.ReLU(name=\"relu1\"), keras.layers.MaxPooling2D((2, 2)), keras.layers.Conv2D(64, (3, 3), padding=\"same\"), keras.layers.ReLU(name=\"relu2\"), keras.layers.MaxPooling2D((2, 2)), keras.layers.Conv2D(64, (3, 3), padding=\"same\"), keras.layers.ReLU(name=\"relu3\"), keras.layers.Flatten(), keras.layers.Dense(64, activation=\"relu\"), keras.layers.Dense(10), ] ) # Compile the mode with the necessary loss function and optimizer. print(\"compiling the convolution model...\") conv_model.compile( optimizer=\"adam\", loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[\"accuracy\"], ) # Train the model. print(\"conv model training...\") conv_hist = conv_model.fit(train_ds, epochs=20, validation_data=test_ds) building the convolution model... compiling the convolution model... conv model training... Epoch 1/20 196/196 [==============================] - 16s 16ms/step - loss: 1.6367 - accuracy: 0.4041 - val_loss: 1.3283 - val_accuracy: 0.5275 Epoch 2/20 196/196 [==============================] - 3s 16ms/step - loss: 1.2207 - accuracy: 0.5675 - val_loss: 1.1365 - val_accuracy: 0.5965 Epoch 3/20 196/196 [==============================] - 3s 16ms/step - loss: 1.0649 - accuracy: 0.6267 - val_loss: 1.0219 - val_accuracy: 0.6378 Epoch 4/20 196/196 [==============================] - 3s 16ms/step - loss: 0.9642 - accuracy: 0.6613 - val_loss: 0.9741 - val_accuracy: 0.6601 Epoch 5/20 196/196 [==============================] - 3s 16ms/step - loss: 0.8779 - accuracy: 0.6939 - val_loss: 0.9145 - val_accuracy: 0.6826 Epoch 6/20 196/196 [==============================] - 3s 16ms/step - loss: 0.8126 - accuracy: 0.7180 - val_loss: 0.8841 - val_accuracy: 0.6913 Epoch 7/20 196/196 [==============================] - 3s 16ms/step - loss: 0.7641 - accuracy: 0.7334 - val_loss: 0.8667 - val_accuracy: 0.7049 Epoch 8/20 196/196 [==============================] - 3s 16ms/step - loss: 0.7210 - accuracy: 0.7503 - val_loss: 0.8363 - val_accuracy: 0.7089 Epoch 9/20 196/196 [==============================] - 3s 16ms/step - loss: 0.6796 - accuracy: 0.7630 - val_loss: 0.8150 - val_accuracy: 0.7203 Epoch 10/20 196/196 [==============================] - 3s 15ms/step - loss: 0.6370 - accuracy: 0.7793 - val_loss: 0.9021 - val_accuracy: 0.6964 Epoch 11/20 196/196 [==============================] - 3s 15ms/step - loss: 0.6089 - accuracy: 0.7886 - val_loss: 0.8336 - val_accuracy: 0.7207 Epoch 12/20 196/196 [==============================] - 3s 15ms/step - loss: 0.5723 - accuracy: 0.8022 - val_loss: 0.8326 - val_accuracy: 0.7246 Epoch 13/20 196/196 [==============================] - 3s 15ms/step - loss: 0.5375 - accuracy: 0.8144 - val_loss: 0.8482 - val_accuracy: 0.7223 Epoch 14/20 196/196 [==============================] - 3s 15ms/step - loss: 0.5121 - accuracy: 0.8230 - val_loss: 0.8244 - val_accuracy: 0.7306 Epoch 15/20 196/196 [==============================] - 3s 15ms/step - loss: 0.4786 - accuracy: 0.8363 - val_loss: 0.8313 - val_accuracy: 0.7363 Epoch 16/20 196/196 [==============================] - 3s 15ms/step - loss: 0.4518 - accuracy: 0.8458 - val_loss: 0.8634 - val_accuracy: 0.7293 Epoch 17/20 196/196 [==============================] - 3s 16ms/step - loss: 0.4403 - accuracy: 0.8489 - val_loss: 0.8683 - val_accuracy: 0.7290 Epoch 18/20 196/196 [==============================] - 3s 16ms/step - loss: 0.4094 - accuracy: 0.8576 - val_loss: 0.8982 - val_accuracy: 0.7272 Epoch 19/20 196/196 [==============================] - 3s 16ms/step - loss: 0.3941 - accuracy: 0.8630 - val_loss: 0.9537 - val_accuracy: 0.7200 Epoch 20/20 196/196 [==============================] - 3s 15ms/step - loss: 0.3778 - accuracy: 0.8691 - val_loss: 0.9780 - val_accuracy: 0.7184 Involutional Neural Network # Build the involution model. print(\"building the involution model...\") inputs = keras.Input(shape=(32, 32, 3)) x, _ = Involution( channel=3, group_number=1, kernel_size=3, stride=1, reduction_ratio=2, name=\"inv_1\" )(inputs) x = keras.layers.ReLU()(x) x = keras.layers.MaxPooling2D((2, 2))(x) x, _ = Involution( channel=3, group_number=1, kernel_size=3, stride=1, reduction_ratio=2, name=\"inv_2\" )(x) x = keras.layers.ReLU()(x) x = keras.layers.MaxPooling2D((2, 2))(x) x, _ = Involution( channel=3, group_number=1, kernel_size=3, stride=1, reduction_ratio=2, name=\"inv_3\" )(x) x = keras.layers.ReLU()(x) x = keras.layers.Flatten()(x) x = keras.layers.Dense(64, activation=\"relu\")(x) outputs = keras.layers.Dense(10)(x) inv_model = keras.Model(inputs=[inputs], outputs=[outputs], name=\"inv_model\") # Compile the mode with the necessary loss function and optimizer. print(\"compiling the involution model...\") inv_model.compile( optimizer=\"adam\", loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[\"accuracy\"], ) # train the model print(\"inv model training...\") inv_hist = inv_model.fit(train_ds, epochs=20, validation_data=test_ds) building the involution model... compiling the involution model... inv model training... Epoch 1/20 196/196 [==============================] - 5s 21ms/step - loss: 2.1570 - accuracy: 0.2266 - val_loss: 2.2712 - val_accuracy: 0.1557 Epoch 2/20 196/196 [==============================] - 4s 20ms/step - loss: 1.9445 - accuracy: 0.3054 - val_loss: 1.9762 - val_accuracy: 0.2963 Epoch 3/20 196/196 [==============================] - 4s 20ms/step - loss: 1.8469 - accuracy: 0.3433 - val_loss: 1.8044 - val_accuracy: 0.3669 Epoch 4/20 196/196 [==============================] - 4s 20ms/step - loss: 1.7837 - accuracy: 0.3646 - val_loss: 1.7640 - val_accuracy: 0.3761 Epoch 5/20 196/196 [==============================] - 4s 20ms/step - loss: 1.7369 - accuracy: 0.3784 - val_loss: 1.7180 - val_accuracy: 0.3907 Epoch 6/20 196/196 [==============================] - 4s 19ms/step - loss: 1.7031 - accuracy: 0.3917 - val_loss: 1.6839 - val_accuracy: 0.4004 Epoch 7/20 196/196 [==============================] - 4s 19ms/step - loss: 1.6748 - accuracy: 0.3988 - val_loss: 1.6786 - val_accuracy: 0.4037 Epoch 8/20 196/196 [==============================] - 4s 19ms/step - loss: 1.6592 - accuracy: 0.4052 - val_loss: 1.6550 - val_accuracy: 0.4103 Epoch 9/20 196/196 [==============================] - 4s 19ms/step - loss: 1.6412 - accuracy: 0.4106 - val_loss: 1.6346 - val_accuracy: 0.4158 Epoch 10/20 196/196 [==============================] - 4s 19ms/step - loss: 1.6251 - accuracy: 0.4178 - val_loss: 1.6330 - val_accuracy: 0.4145 Epoch 11/20 196/196 [==============================] - 4s 19ms/step - loss: 1.6124 - accuracy: 0.4206 - val_loss: 1.6214 - val_accuracy: 0.4218 Epoch 12/20 196/196 [==============================] - 4s 19ms/step - loss: 1.5978 - accuracy: 0.4252 - val_loss: 1.6121 - val_accuracy: 0.4239 Epoch 13/20 196/196 [==============================] - 4s 19ms/step - loss: 1.5868 - accuracy: 0.4301 - val_loss: 1.5974 - val_accuracy: 0.4284 Epoch 14/20 196/196 [==============================] - 4s 19ms/step - loss: 1.5759 - accuracy: 0.4353 - val_loss: 1.5939 - val_accuracy: 0.4325 Epoch 15/20 196/196 [==============================] - 4s 19ms/step - loss: 1.5677 - accuracy: 0.4369 - val_loss: 1.5889 - val_accuracy: 0.4372 Epoch 16/20 196/196 [==============================] - 4s 20ms/step - loss: 1.5586 - accuracy: 0.4413 - val_loss: 1.5817 - val_accuracy: 0.4376 Epoch 17/20 196/196 [==============================] - 4s 20ms/step - loss: 1.5507 - accuracy: 0.4447 - val_loss: 1.5776 - val_accuracy: 0.4381 Epoch 18/20 196/196 [==============================] - 4s 20ms/step - loss: 1.5420 - accuracy: 0.4477 - val_loss: 1.5785 - val_accuracy: 0.4378 Epoch 19/20 196/196 [==============================] - 4s 20ms/step - loss: 1.5357 - accuracy: 0.4484 - val_loss: 1.5639 - val_accuracy: 0.4431 Epoch 20/20 196/196 [==============================] - 4s 20ms/step - loss: 1.5305 - accuracy: 0.4530 - val_loss: 1.5661 - val_accuracy: 0.4418 Comparisons In this section, we will be looking at both the models and compare a few pointers. Parameters One can see that with a similar architecture the parameters in a CNN is much larger than that of an INN (Involutional Neural Network). conv_model.summary() inv_model.summary() Model: \"sequential_3\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_6 (Conv2D) (None, 32, 32, 32) 896 _________________________________________________________________ relu1 (ReLU) (None, 32, 32, 32) 0 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 16, 16, 32) 0 _________________________________________________________________ conv2d_7 (Conv2D) (None, 16, 16, 64) 18496 _________________________________________________________________ relu2 (ReLU) (None, 16, 16, 64) 0 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 8, 8, 64) 0 _________________________________________________________________ conv2d_8 (Conv2D) (None, 8, 8, 64) 36928 _________________________________________________________________ relu3 (ReLU) (None, 8, 8, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 4096) 0 _________________________________________________________________ dense (Dense) (None, 64) 262208 _________________________________________________________________ dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 319,178 Trainable params: 319,178 Non-trainable params: 0 _________________________________________________________________ Model: \"inv_model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 32, 32, 3)] 0 _________________________________________________________________ inv_1 (Involution) ((None, 32, 32, 3), (None 26 _________________________________________________________________ re_lu_3 (ReLU) (None, 32, 32, 3) 0 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 16, 16, 3) 0 _________________________________________________________________ inv_2 (Involution) ((None, 16, 16, 3), (None 26 _________________________________________________________________ re_lu_4 (ReLU) (None, 16, 16, 3) 0 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 8, 8, 3) 0 _________________________________________________________________ inv_3 (Involution) ((None, 8, 8, 3), (None, 26 _________________________________________________________________ re_lu_5 (ReLU) (None, 8, 8, 3) 0 _________________________________________________________________ flatten_1 (Flatten) (None, 192) 0 _________________________________________________________________ dense_2 (Dense) (None, 64) 12352 _________________________________________________________________ dense_3 (Dense) (None, 10) 650 ================================================================= Total params: 13,080 Trainable params: 13,074 Non-trainable params: 6 _________________________________________________________________ Loss and Accuracy Plots Here, the loss and the accuracy plots demonstrate that INNs are slow learners (with lower parameters). plt.figure(figsize=(20, 5)) plt.subplot(1, 2, 1) plt.title(\"Convolution Loss\") plt.plot(conv_hist.history[\"loss\"], label=\"loss\") plt.plot(conv_hist.history[\"val_loss\"], label=\"val_loss\") plt.legend() plt.subplot(1, 2, 2) plt.title(\"Involution Loss\") plt.plot(inv_hist.history[\"loss\"], label=\"loss\") plt.plot(inv_hist.history[\"val_loss\"], label=\"val_loss\") plt.legend() plt.show() plt.figure(figsize=(20, 5)) plt.subplot(1, 2, 1) plt.title(\"Convolution Accuracy\") plt.plot(conv_hist.history[\"accuracy\"], label=\"accuracy\") plt.plot(conv_hist.history[\"val_accuracy\"], label=\"val_accuracy\") plt.legend() plt.subplot(1, 2, 2) plt.title(\"Involution Accuracy\") plt.plot(inv_hist.history[\"accuracy\"], label=\"accuracy\") plt.plot(inv_hist.history[\"val_accuracy\"], label=\"val_accuracy\") plt.legend() plt.show() png png Visualizing Involution Kernels To visualize the kernels, we take the sum of K×K values from each involution kernel. All the representatives at different spatial locations frame the corresponding heat map. The authors mention: \"Our proposed involution is reminiscent of self-attention and essentially could become a generalized version of it.\" With the visualization of the kernel we can indeed obtain an attention map of the image. The learned involution kernels provides attention to individual spatial positions of the input tensor. The location-specific property makes involution a generic space of models in which self-attention belongs. layer_names = [\"inv_1\", \"inv_2\", \"inv_3\"] outputs = [inv_model.get_layer(name).output for name in layer_names] vis_model = keras.Model(inv_model.input, outputs) fig, axes = plt.subplots(nrows=10, ncols=4, figsize=(10, 30)) for ax, test_image in zip(axes, test_images[:10]): (inv1_out, inv2_out, inv3_out) = vis_model.predict(test_image[None, ...]) _, inv1_kernel = inv1_out _, inv2_kernel = inv2_out _, inv3_kernel = inv3_out inv1_kernel = tf.reduce_sum(inv1_kernel, axis=[-1, -2, -3]) inv2_kernel = tf.reduce_sum(inv2_kernel, axis=[-1, -2, -3]) inv3_kernel = tf.reduce_sum(inv3_kernel, axis=[-1, -2, -3]) ax[0].imshow(keras.preprocessing.image.array_to_img(test_image)) ax[0].set_title(\"Input Image\") ax[1].imshow(keras.preprocessing.image.array_to_img(inv1_kernel[0, ..., None])) ax[1].set_title(\"Involution Kernel 1\") ax[2].imshow(keras.preprocessing.image.array_to_img(inv2_kernel[0, ..., None])) ax[2].set_title(\"Involution Kernel 2\") ax[3].imshow(keras.preprocessing.image.array_to_img(inv3_kernel[0, ..., None])) ax[3].set_title(\"Involution Kernel 3\") png Conclusions In this example, the main focus was to build an Involution layer which can be easily reused. While our comparisons were based on a specific task, feel free to use the layer for different tasks and report your results. According to me, the key take-away of involution is its relationship with self-attention. The intuition behind location-specific and channel-spefic processing makes sense in a lot of tasks. Moving forward one can: Look at Yannick's video on involution for a better understanding. Experiment with the various hyperparameters of the involution layer. Build different models with the involution layer. Try building a different kernel generation method altogether. Training a keypoint detector with data augmentation and transfer learning. Keypoint detection consists of locating key object parts. For example, the key parts of our faces include nose tips, eyebrows, eye corners, and so on. These parts help to represent the underlying object in a feature-rich manner. Keypoint detection has applications that include pose estimation, face detection, etc. In this example, we will build a keypoint detector using the StanfordExtra dataset, using transfer learning. This example requires TensorFlow 2.4 or higher, as well as imgaug library, which can be installed using the following command: !pip install -q -U imgaug Data collection The StanfordExtra dataset contains 12,000 images of dogs together with keypoints and segmentation maps. It is developed from the Stanford dogs dataset. It can be downloaded with the command below: !wget -q http://vision.stanford.edu/aditya86/ImageNetDogs/images.tar Annotations are provided as a single JSON file in the StanfordExtra dataset and one needs to fill this form to get access to it. The authors explicitly instruct users not to share the JSON file, and this example respects this wish: you should obtain the JSON file yourself. The JSON file is expected to be locally available as stanfordextra_v12.zip. After the files are downloaded, we can extract the archives. !tar xf images.tar !unzip -qq ~/stanfordextra_v12.zip Imports from tensorflow.keras import layers from tensorflow import keras import tensorflow as tf from imgaug.augmentables.kps import KeypointsOnImage from imgaug.augmentables.kps import Keypoint import imgaug.augmenters as iaa from PIL import Image from sklearn.model_selection import train_test_split from matplotlib import pyplot as plt import pandas as pd import numpy as np import json import os Define hyperparameters IMG_SIZE = 224 BATCH_SIZE = 64 EPOCHS = 5 NUM_KEYPOINTS = 24 * 2 # 24 pairs each having x and y coordinates Load data The authors also provide a metadata file that specifies additional information about the keypoints, like color information, animal pose name, etc. We will load this file in a pandas dataframe to extract information for visualization purposes. IMG_DIR = \"Images\" JSON = \"StanfordExtra_V12/StanfordExtra_v12.json\" KEYPOINT_DEF = ( \"https://github.com/benjiebob/StanfordExtra/raw/master/keypoint_definitions.csv\" ) # Load the ground-truth annotations. with open(JSON) as infile: json_data = json.load(infile) # Set up a dictionary, mapping all the ground-truth information # with respect to the path of the image. json_dict = {i[\"img_path\"]: i for i in json_data} A single entry of json_dict looks like the following: 'n02085782-Japanese_spaniel/n02085782_2886.jpg': {'img_bbox': [205, 20, 116, 201], 'img_height': 272, 'img_path': 'n02085782-Japanese_spaniel/n02085782_2886.jpg', 'img_width': 350, 'is_multiple_dogs': False, 'joints': [[108.66666666666667, 252.0, 1], [147.66666666666666, 229.0, 1], [163.5, 208.5, 1], [0, 0, 0], [0, 0, 0], [0, 0, 0], [54.0, 244.0, 1], [77.33333333333333, 225.33333333333334, 1], [79.0, 196.5, 1], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [150.66666666666666, 86.66666666666667, 1], [88.66666666666667, 73.0, 1], [116.0, 106.33333333333333, 1], [109.0, 123.33333333333333, 1], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], 'seg': ...} In this example, the keys we are interested in are: img_path joints There are a total of 24 entries present inside joints. Each entry has 3 values: x-coordinate y-coordinate visibility flag of the keypoints (1 indicates visibility and 0 indicates non-visibility) As we can see joints contain multiple [0, 0, 0] entries which denote that those keypoints were not labeled. In this example, we will consider both non-visible as well as unlabeled keypoints in order to allow mini-batch learning. # Load the metdata definition file and preview it. keypoint_def = pd.read_csv(KEYPOINT_DEF) keypoint_def.head() # Extract the colours and labels. colours = keypoint_def[\"Hex colour\"].values.tolist() colours = [\"#\" + colour for colour in colours] labels = keypoint_def[\"Name\"].values.tolist() # Utility for reading an image and for getting its annotations. def get_dog(name): data = json_dict[name] img_data = plt.imread(os.path.join(IMG_DIR, data[\"img_path\"])) # If the image is RGBA convert it to RGB. if img_data.shape[-1] == 4: img_data = img_data.astype(np.uint8) img_data = Image.fromarray(img_data) img_data = np.array(img_data.convert(\"RGB\")) data[\"img_data\"] = img_data return data Visualize data Now, we write a utility function to visualize the images and their keypoints. # Parts of this code come from here: # https://github.com/benjiebob/StanfordExtra/blob/master/demo.ipynb def visualize_keypoints(images, keypoints): fig, axes = plt.subplots(nrows=len(images), ncols=2, figsize=(16, 12)) [ax.axis(\"off\") for ax in np.ravel(axes)] for (ax_orig, ax_all), image, current_keypoint in zip(axes, images, keypoints): ax_orig.imshow(image) ax_all.imshow(image) # If the keypoints were formed by `imgaug` then the coordinates need # to be iterated differently. if isinstance(current_keypoint, KeypointsOnImage): for idx, kp in enumerate(current_keypoint.keypoints): ax_all.scatter( [kp.x], [kp.y], c=colours[idx], marker=\"x\", s=50, linewidths=5 ) else: current_keypoint = np.array(current_keypoint) # Since the last entry is the visibility flag, we discard it. current_keypoint = current_keypoint[:, :2] for idx, (x, y) in enumerate(current_keypoint): ax_all.scatter([x], [y], c=colours[idx], marker=\"x\", s=50, linewidths=5) plt.tight_layout(pad=2.0) plt.show() # Select four samples randomly for visualization. samples = list(json_dict.keys()) num_samples = 4 selected_samples = np.random.choice(samples, num_samples, replace=False) images, keypoints = [], [] for sample in selected_samples: data = get_dog(sample) image = data[\"img_data\"] keypoint = data[\"joints\"] images.append(image) keypoints.append(keypoint) visualize_keypoints(images, keypoints) png The plots show that we have images of non-uniform sizes, which is expected in most real-world scenarios. However, if we resize these images to have a uniform shape (for instance (224 x 224)) their ground-truth annotations will also be affected. The same applies if we apply any geometric transformation (horizontal flip, for e.g.) to an image. Fortunately, imgaug provides utilities that can handle this issue. In the next section, we will write a data generator inheriting the [keras.utils.Sequence](/api/utils/python_utils#sequence-class) class that applies data augmentation on batches of data using imgaug. Prepare data generator class KeyPointsDataset(keras.utils.Sequence): def __init__(self, image_keys, aug, batch_size=BATCH_SIZE, train=True): self.image_keys = image_keys self.aug = aug self.batch_size = batch_size self.train = train self.on_epoch_end() def __len__(self): return len(self.image_keys) // self.batch_size def on_epoch_end(self): self.indexes = np.arange(len(self.image_keys)) if self.train: np.random.shuffle(self.indexes) def __getitem__(self, index): indexes = self.indexes[index * self.batch_size : (index + 1) * self.batch_size] image_keys_temp = [self.image_keys[k] for k in indexes] (images, keypoints) = self.__data_generation(image_keys_temp) return (images, keypoints) def __data_generation(self, image_keys_temp): batch_images = np.empty((self.batch_size, IMG_SIZE, IMG_SIZE, 3), dtype=\"int\") batch_keypoints = np.empty( (self.batch_size, 1, 1, NUM_KEYPOINTS), dtype=\"float32\" ) for i, key in enumerate(image_keys_temp): data = get_dog(key) current_keypoint = np.array(data[\"joints\"])[:, :2] kps = [] # To apply our data augmentation pipeline, we first need to # form Keypoint objects with the original coordinates. for j in range(0, len(current_keypoint)): kps.append(Keypoint(x=current_keypoint[j][0], y=current_keypoint[j][1])) # We then project the original image and its keypoint coordinates. current_image = data[\"img_data\"] kps_obj = KeypointsOnImage(kps, shape=current_image.shape) # Apply the augmentation pipeline. (new_image, new_kps_obj) = self.aug(image=current_image, keypoints=kps_obj) batch_images[i,] = new_image # Parse the coordinates from the new keypoint object. kp_temp = [] for keypoint in new_kps_obj: kp_temp.append(np.nan_to_num(keypoint.x)) kp_temp.append(np.nan_to_num(keypoint.y)) # More on why this reshaping later. batch_keypoints[i,] = np.array(kp_temp).reshape(1, 1, 24 * 2) # Scale the coordinates to [0, 1] range. batch_keypoints = batch_keypoints / IMG_SIZE return (batch_images, batch_keypoints) To know more about how to operate with keypoints in imgaug check out this document. Define augmentation transforms train_aug = iaa.Sequential( [ iaa.Resize(IMG_SIZE, interpolation=\"linear\"), iaa.Fliplr(0.3), # `Sometimes()` applies a function randomly to the inputs with # a given probability (0.3, in this case). iaa.Sometimes(0.3, iaa.Affine(rotate=10, scale=(0.5, 0.7))), ] ) test_aug = iaa.Sequential([iaa.Resize(IMG_SIZE, interpolation=\"linear\")]) Create training and validation splits np.random.shuffle(samples) train_keys, validation_keys = ( samples[int(len(samples) * 0.15) :], samples[: int(len(samples) * 0.15)], ) Data generator investigation train_dataset = KeyPointsDataset(train_keys, train_aug) validation_dataset = KeyPointsDataset(validation_keys, test_aug, train=False) print(f\"Total batches in training set: {len(train_dataset)}\") print(f\"Total batches in validation set: {len(validation_dataset)}\") sample_images, sample_keypoints = next(iter(train_dataset)) assert sample_keypoints.max() == 1.0 assert sample_keypoints.min() == 0.0 sample_keypoints = sample_keypoints[:4].reshape(-1, 24, 2) * IMG_SIZE visualize_keypoints(sample_images[:4], sample_keypoints) Total batches in training set: 166 Total batches in validation set: 29 png Model building The Stanford dogs dataset (on which the StanfordExtra dataset is based) was built using the ImageNet-1k dataset. So, it is likely that the models pretrained on the ImageNet-1k dataset would be useful for this task. We will use a MobileNetV2 pre-trained on this dataset as a backbone to extract meaningful features from the images and then pass those to a custom regression head for predicting coordinates. def get_model(): # Load the pre-trained weights of MobileNetV2 and freeze the weights backbone = keras.applications.MobileNetV2( weights=\"imagenet\", include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3) ) backbone.trainable = False inputs = layers.Input((IMG_SIZE, IMG_SIZE, 3)) x = keras.applications.mobilenet_v2.preprocess_input(inputs) x = backbone(x) x = layers.Dropout(0.3)(x) x = layers.SeparableConv2D( NUM_KEYPOINTS, kernel_size=5, strides=1, activation=\"relu\" )(x) outputs = layers.SeparableConv2D( NUM_KEYPOINTS, kernel_size=3, strides=1, activation=\"sigmoid\" )(x) return keras.Model(inputs, outputs, name=\"keypoint_detector\") Our custom network is fully-convolutional which makes it more parameter-friendly than the same version of the network having fully-connected dense layers. get_model().summary() Model: \"keypoint_detector\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) [(None, 224, 224, 3)] 0 _________________________________________________________________ tf.math.truediv (TFOpLambda) (None, 224, 224, 3) 0 _________________________________________________________________ tf.math.subtract (TFOpLambda (None, 224, 224, 3) 0 _________________________________________________________________ mobilenetv2_1.00_224 (Functi (None, 7, 7, 1280) 2257984 _________________________________________________________________ dropout (Dropout) (None, 7, 7, 1280) 0 _________________________________________________________________ separable_conv2d (SeparableC (None, 3, 3, 48) 93488 _________________________________________________________________ separable_conv2d_1 (Separabl (None, 1, 1, 48) 2784 ================================================================= Total params: 2,354,256 Trainable params: 96,272 Non-trainable params: 2,257,984 _________________________________________________________________ Notice the output shape of the network: (None, 1, 1, 48). This is why we have reshaped the coordinates as: batch_keypoints[i, :] = np.array(kp_temp).reshape(1, 1, 24 * 2). Model compilation and training For this example, we will train the network only for five epochs. model = get_model() model.compile(loss=\"mse\", optimizer=keras.optimizers.Adam(1e-4)) model.fit(train_dataset, validation_data=validation_dataset, epochs=EPOCHS) Epoch 1/5 166/166 [==============================] - 85s 486ms/step - loss: 0.1087 - val_loss: 0.0950 Epoch 2/5 166/166 [==============================] - 78s 471ms/step - loss: 0.0830 - val_loss: 0.0778 Epoch 3/5 166/166 [==============================] - 78s 468ms/step - loss: 0.0778 - val_loss: 0.0739 Epoch 4/5 166/166 [==============================] - 78s 470ms/step - loss: 0.0753 - val_loss: 0.0711 Epoch 5/5 166/166 [==============================] - 78s 468ms/step - loss: 0.0735 - val_loss: 0.0692 Make predictions and visualize them sample_val_images, sample_val_keypoints = next(iter(validation_dataset)) sample_val_images = sample_val_images[:4] sample_val_keypoints = sample_val_keypoints[:4].reshape(-1, 24, 2) * IMG_SIZE predictions = model.predict(sample_val_images).reshape(-1, 24, 2) * IMG_SIZE # Ground-truth visualize_keypoints(sample_val_images, sample_val_keypoints) # Predictions visualize_keypoints(sample_val_images, predictions) png png Predictions will likely improve with more training. Going further Try using other augmentation transforms from imgaug to investigate how that changes the results. Here, we transferred the features from the pre-trained network linearly that is we did not fine-tune it. You are encouraged to fine-tune it on this task and see if that improves the performance. You can also try different architectures and see how they affect the final performance. Implementation of classical Knowledge Distillation. Introduction to Knowledge Distillation Knowledge Distillation is a procedure for model compression, in which a small (student) model is trained to match a large pre-trained (teacher) model. Knowledge is transferred from the teacher model to the student by minimizing a loss function, aimed at matching softened teacher logits as well as ground-truth labels. The logits are softened by applying a \"temperature\" scaling function in the softmax, effectively smoothing out the probability distribution and revealing inter-class relationships learned by the teacher. Reference: Hinton et al. (2015) Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import numpy as np Construct Distiller() class The custom Distiller() class, overrides the Model methods train_step, test_step, and compile(). In order to use the distiller, we need: A trained teacher model A student model to train A student loss function on the difference between student predictions and ground-truth A distillation loss function, along with a temperature, on the difference between the soft student predictions and the soft teacher labels An alpha factor to weight the student and distillation loss An optimizer for the student and (optional) metrics to evaluate performance In the train_step method, we perform a forward pass of both the teacher and student, calculate the loss with weighting of the student_loss and distillation_loss by alpha and 1 - alpha, respectively, and perform the backward pass. Note: only the student weights are updated, and therefore we only calculate the gradients for the student weights. In the test_step method, we evaluate the student model on the provided dataset. class Distiller(keras.Model): def __init__(self, student, teacher): super(Distiller, self).__init__() self.teacher = teacher self.student = student def compile( self, optimizer, metrics, student_loss_fn, distillation_loss_fn, alpha=0.1, temperature=3, ): \"\"\" Configure the distiller. Args: optimizer: Keras optimizer for the student weights metrics: Keras metrics for evaluation student_loss_fn: Loss function of difference between student predictions and ground-truth distillation_loss_fn: Loss function of difference between soft student predictions and soft teacher predictions alpha: weight to student_loss_fn and 1-alpha to distillation_loss_fn temperature: Temperature for softening probability distributions. Larger temperature gives softer distributions. \"\"\" super(Distiller, self).compile(optimizer=optimizer, metrics=metrics) self.student_loss_fn = student_loss_fn self.distillation_loss_fn = distillation_loss_fn self.alpha = alpha self.temperature = temperature def train_step(self, data): # Unpack data x, y = data # Forward pass of teacher teacher_predictions = self.teacher(x, training=False) with tf.GradientTape() as tape: # Forward pass of student student_predictions = self.student(x, training=True) # Compute losses student_loss = self.student_loss_fn(y, student_predictions) distillation_loss = self.distillation_loss_fn( tf.nn.softmax(teacher_predictions / self.temperature, axis=1), tf.nn.softmax(student_predictions / self.temperature, axis=1), ) loss = self.alpha * student_loss + (1 - self.alpha) * distillation_loss # Compute gradients trainable_vars = self.student.trainable_variables gradients = tape.gradient(loss, trainable_vars) # Update weights self.optimizer.apply_gradients(zip(gradients, trainable_vars)) # Update the metrics configured in `compile()`. self.compiled_metrics.update_state(y, student_predictions) # Return a dict of performance results = {m.name: m.result() for m in self.metrics} results.update( {\"student_loss\": student_loss, \"distillation_loss\": distillation_loss} ) return results def test_step(self, data): # Unpack the data x, y = data # Compute predictions y_prediction = self.student(x, training=False) # Calculate the loss student_loss = self.student_loss_fn(y, y_prediction) # Update the metrics. self.compiled_metrics.update_state(y, y_prediction) # Return a dict of performance results = {m.name: m.result() for m in self.metrics} results.update({\"student_loss\": student_loss}) return results Create student and teacher models Initialy, we create a teacher model and a smaller student model. Both models are convolutional neural networks and created using Sequential(), but could be any Keras model. # Create the teacher teacher = keras.Sequential( [ keras.Input(shape=(28, 28, 1)), layers.Conv2D(256, (3, 3), strides=(2, 2), padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding=\"same\"), layers.Conv2D(512, (3, 3), strides=(2, 2), padding=\"same\"), layers.Flatten(), layers.Dense(10), ], name=\"teacher\", ) # Create the student student = keras.Sequential( [ keras.Input(shape=(28, 28, 1)), layers.Conv2D(16, (3, 3), strides=(2, 2), padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding=\"same\"), layers.Conv2D(32, (3, 3), strides=(2, 2), padding=\"same\"), layers.Flatten(), layers.Dense(10), ], name=\"student\", ) # Clone student for later comparison student_scratch = keras.models.clone_model(student) Prepare the dataset The dataset used for training the teacher and distilling the teacher is MNIST, and the procedure would be equivalent for any other dataset, e.g. CIFAR-10, with a suitable choice of models. Both the student and teacher are trained on the training set and evaluated on the test set. # Prepare the train and test dataset. batch_size = 64 (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() # Normalize data x_train = x_train.astype(\"float32\") / 255.0 x_train = np.reshape(x_train, (-1, 28, 28, 1)) x_test = x_test.astype(\"float32\") / 255.0 x_test = np.reshape(x_test, (-1, 28, 28, 1)) Train the teacher In knowledge distillation we assume that the teacher is trained and fixed. Thus, we start by training the teacher model on the training set in the usual way. # Train teacher as usual teacher.compile( optimizer=keras.optimizers.Adam(), loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[keras.metrics.SparseCategoricalAccuracy()], ) # Train and evaluate teacher on data. teacher.fit(x_train, y_train, epochs=5) teacher.evaluate(x_test, y_test) Epoch 1/5 1875/1875 [==============================] - 248s 132ms/step - loss: 0.2438 - sparse_categorical_accuracy: 0.9220 Epoch 2/5 1875/1875 [==============================] - 263s 140ms/step - loss: 0.0881 - sparse_categorical_accuracy: 0.9738 Epoch 3/5 1875/1875 [==============================] - 245s 131ms/step - loss: 0.0650 - sparse_categorical_accuracy: 0.9811 Epoch 5/5 363/1875 [====>.........................] - ETA: 3:18 - loss: 0.0555 - sparse_categorical_accuracy: 0.9839 Distill teacher to student We have already trained the teacher model, and we only need to initialize a Distiller(student, teacher) instance, compile() it with the desired losses, hyperparameters and optimizer, and distill the teacher to the student. # Initialize and compile distiller distiller = Distiller(student=student, teacher=teacher) distiller.compile( optimizer=keras.optimizers.Adam(), metrics=[keras.metrics.SparseCategoricalAccuracy()], student_loss_fn=keras.losses.SparseCategoricalCrossentropy(from_logits=True), distillation_loss_fn=keras.losses.KLDivergence(), alpha=0.1, temperature=10, ) # Distill teacher to student distiller.fit(x_train, y_train, epochs=3) # Evaluate student on test dataset distiller.evaluate(x_test, y_test) Epoch 1/3 1875/1875 [==============================] - 242s 129ms/step - sparse_categorical_accuracy: 0.9761 - student_loss: 0.1526 - distillation_loss: 0.0226 Epoch 2/3 1875/1875 [==============================] - 281s 150ms/step - sparse_categorical_accuracy: 0.9863 - student_loss: 0.1384 - distillation_loss: 0.0185 Epoch 3/3 399/1875 [=====>........................] - ETA: 3:27 - sparse_categorical_accuracy: 0.9896 - student_loss: 0.1300 - distillation_loss: 0.0182 Train student from scratch for comparison We can also train an equivalent student model from scratch without the teacher, in order to evaluate the performance gain obtained by knowledge distillation. # Train student as doen usually student_scratch.compile( optimizer=keras.optimizers.Adam(), loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[keras.metrics.SparseCategoricalAccuracy()], ) # Train and evaluate student trained from scratch. student_scratch.fit(x_train, y_train, epochs=3) student_scratch.evaluate(x_test, y_test) Epoch 1/3 1875/1875 [==============================] - 4s 2ms/step - loss: 0.4731 - sparse_categorical_accuracy: 0.8550 Epoch 2/3 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0966 - sparse_categorical_accuracy: 0.9710 Epoch 3/3 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0750 - sparse_categorical_accuracy: 0.9773 313/313 [==============================] - 0s 963us/step - loss: 0.0691 - sparse_categorical_accuracy: 0.9778 [0.06905383616685867, 0.9778000116348267] If the teacher is trained for 5 full epochs and the student is distilled on this teacher for 3 full epochs, you should in this example experience a performance boost compared to training the same student model from scratch, and even compared to the teacher itself. You should expect the teacher to have accuracy around 97.6%, the student trained from scratch should be around 97.6%, and the distilled student should be around 98.1%. Remove or try out different seeds to use different weight initializations. How to optimally learn representations of images for a given resolution. It is a common belief that if we constrain vision models to perceive things as humans do, their performance can be improved. For example, in this work, Geirhos et al. showed that the vision models pre-trained on the ImageNet-1k dataset are biased toward texture whereas human beings mostly use the shape descriptor to develop a common perception. But does this belief always apply especially when it comes to improving the performance of vision models? It turns out it may not always be the case. When training vision models, it is common to resize images to a lower dimension ((224 x 224), (299 x 299), etc.) to allow mini-batch learning and also to keep up the compute limitations. We generally make use of image resizing methods like bilinear interpolation for this step and the resized images do not lose much of their perceptual character to the human eyes. In Learning to Resize Images for Computer Vision Tasks, Talebi et al. show that if we try to optimize the perceptual quality of the images for the vision models rather than the human eyes, their performance can further be improved. They investigate the following question: For a given image resolution and a model, how to best resize the given images? As shown in the paper, this idea helps to consistently improve the performance of the common vision models (pre-trained on ImageNet-1k) like DenseNet-121, ResNet-50, MobileNetV2, and EfficientNets. In this example, we will implement the learnable image resizing module as proposed in the paper and demonstrate that on the Cats and Dogs dataset using the DenseNet-121 architecture. This example requires TensorFlow 2.4 or higher. Setup from tensorflow.keras import layers from tensorflow import keras import tensorflow as tf import tensorflow_datasets as tfds tfds.disable_progress_bar() import matplotlib.pyplot as plt import numpy as np Define hyperparameters In order to facilitate mini-batch learning, we need to have a fixed shape for the images inside a given batch. This is why an initial resizing is required. We first resize all the images to (300 x 300) shape and then learn their optimal representation for the (150 x 150) resolution. INP_SIZE = (300, 300) TARGET_SIZE = (150, 150) INTERPOLATION = \"bilinear\" AUTO = tf.data.AUTOTUNE BATCH_SIZE = 64 EPOCHS = 5 In this example, we will use the bilinear interpolation but the learnable image resizer module is not dependent on any specific interpolation method. We can also use others, such as bicubic. Load and prepare the dataset For this example, we will only use 40% of the total training dataset. train_ds, validation_ds = tfds.load( \"cats_vs_dogs\", # Reserve 10% for validation split=[\"train[:40%]\", \"train[40%:50%]\"], as_supervised=True, ) def preprocess_dataset(image, label): image = tf.image.resize(image, (INP_SIZE[0], INP_SIZE[1])) label = tf.one_hot(label, depth=2) return (image, label) train_ds = ( train_ds.shuffle(BATCH_SIZE * 100) .map(preprocess_dataset, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) validation_ds = ( validation_ds.map(preprocess_dataset, num_parallel_calls=AUTO) .batch(BATCH_SIZE) .prefetch(AUTO) ) Downloading and preparing dataset 786.68 MiB (download: 786.68 MiB, generated: Unknown size, total: 786.68 MiB) to /home/jupyter/tensorflow_datasets/cats_vs_dogs/4.0.0... WARNING:absl:1738 images were corrupted and were skipped Dataset cats_vs_dogs downloaded and prepared to /home/jupyter/tensorflow_datasets/cats_vs_dogs/4.0.0. Subsequent calls will reuse this data. Define the learnable resizer utilities The figure below (courtesy: Learning to Resize Images for Computer Vision Tasks) presents the structure of the learnable resizing module: def conv_block(x, filters, kernel_size, strides, activation=layers.LeakyReLU(0.2)): x = layers.Conv2D(filters, kernel_size, strides, padding=\"same\", use_bias=False)(x) x = layers.BatchNormalization()(x) if activation: x = activation(x) return x def res_block(x): inputs = x x = conv_block(x, 16, 3, 1) x = conv_block(x, 16, 3, 1, activation=None) return layers.Add()([inputs, x]) def get_learnable_resizer(filters=16, num_res_blocks=1, interpolation=INTERPOLATION): inputs = layers.Input(shape=[None, None, 3]) # First, perform naive resizing. naive_resize = layers.Resizing( *TARGET_SIZE, interpolation=interpolation )(inputs) # First convolution block without batch normalization. x = layers.Conv2D(filters=filters, kernel_size=7, strides=1, padding=\"same\")(inputs) x = layers.LeakyReLU(0.2)(x) # Second convolution block with batch normalization. x = layers.Conv2D(filters=filters, kernel_size=1, strides=1, padding=\"same\")(x) x = layers.LeakyReLU(0.2)(x) x = layers.BatchNormalization()(x) # Intermediate resizing as a bottleneck. bottleneck = layers.Resizing( *TARGET_SIZE, interpolation=interpolation )(x) # Residual passes. for _ in range(num_res_blocks): x = res_block(bottleneck) # Projection. x = layers.Conv2D( filters=filters, kernel_size=3, strides=1, padding=\"same\", use_bias=False )(x) x = layers.BatchNormalization()(x) # Skip connection. x = layers.Add()([bottleneck, x]) # Final resized image. x = layers.Conv2D(filters=3, kernel_size=7, strides=1, padding=\"same\")(x) final_resize = layers.Add()([naive_resize, x]) return tf.keras.Model(inputs, final_resize, name=\"learnable_resizer\") learnable_resizer = get_learnable_resizer() Visualize the outputs of the learnable resizing module Here, we visualize how the resized images would look like after being passed through the random weights of the resizer. sample_images, _ = next(iter(train_ds)) plt.figure(figsize=(16, 10)) for i, image in enumerate(sample_images[:6]): image = image / 255 ax = plt.subplot(3, 4, 2 * i + 1) plt.title(\"Input Image\") plt.imshow(image.numpy().squeeze()) plt.axis(\"off\") ax = plt.subplot(3, 4, 2 * i + 2) resized_image = learnable_resizer(image[None, ...]) plt.title(\"Resized Image\") plt.imshow(resized_image.numpy().squeeze()) plt.axis(\"off\") WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). png Model building utility def get_model(): backbone = tf.keras.applications.DenseNet121( weights=None, include_top=True, classes=2, input_shape=((TARGET_SIZE[0], TARGET_SIZE[1], 3)), ) backbone.trainable = True inputs = layers.Input((INP_SIZE[0], INP_SIZE[1], 3)) x = layers.Rescaling(scale=1.0 / 255)(inputs) x = learnable_resizer(x) outputs = backbone(x) return tf.keras.Model(inputs, outputs) The structure of the learnable image resizer module allows for flexible integrations with different vision models. Compile and train our model with learnable resizer model = get_model() model.compile( loss=keras.losses.CategoricalCrossentropy(label_smoothing=0.1), optimizer=\"sgd\", metrics=[\"accuracy\"], ) model.fit(train_ds, validation_data=validation_ds, epochs=EPOCHS) Epoch 1/5 146/146 [==============================] - 49s 247ms/step - loss: 0.6956 - accuracy: 0.5697 - val_loss: 0.6958 - val_accuracy: 0.5103 Epoch 2/5 146/146 [==============================] - 33s 216ms/step - loss: 0.6685 - accuracy: 0.6117 - val_loss: 0.6955 - val_accuracy: 0.5387 Epoch 3/5 146/146 [==============================] - 33s 216ms/step - loss: 0.6542 - accuracy: 0.6190 - val_loss: 0.7410 - val_accuracy: 0.5684 Epoch 4/5 146/146 [==============================] - 33s 216ms/step - loss: 0.6357 - accuracy: 0.6576 - val_loss: 0.9322 - val_accuracy: 0.5314 Epoch 5/5 146/146 [==============================] - 33s 215ms/step - loss: 0.6224 - accuracy: 0.6745 - val_loss: 0.6526 - val_accuracy: 0.6672 Visualize the outputs of the trained visualizer plt.figure(figsize=(16, 10)) for i, image in enumerate(sample_images[:6]): image = image / 255 ax = plt.subplot(3, 4, 2 * i + 1) plt.title(\"Input Image\") plt.imshow(image.numpy().squeeze()) plt.axis(\"off\") ax = plt.subplot(3, 4, 2 * i + 2) resized_image = learnable_resizer(image[None, ...]) plt.title(\"Resized Image\") plt.imshow(resized_image.numpy().squeeze() / 10) plt.axis(\"off\") WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). png The plot shows that the visuals of the images have improved with training. The following table shows the benefits of using the resizing module in comparison to using the bilinear interpolation: Model Number of parameters (Million) Top-1 accuracy With the learnable resizer 7.051717 67.67% Without the learnable resizer 7.039554 60.19% For more details, you can check out this repository. Note the above-reported models were trained for 10 epochs on 90% of the training set of Cats and Dogs unlike this example. Also, note that the increase in the number of parameters due to the resizing module is very negligible. To ensure that the improvement in the performance is not due to stochasticity, the models were trained using the same initial random weights. Now, a question worth asking here is - isn't the improved accuracy simply a consequence of adding more layers (the resizer is a mini network after all) to the model, compared to the baseline? To show that it is not the case, the authors conduct the following experiment: Take a pre-trained model trained some size, say (224 x 224). Now, first, use it to infer predictions on images resized to a lower resolution. Record the performance. For the second experiment, plug in the resizer module at the top of the pre-trained model and warm-start the training. Record the performance. Now, the authors argue that using the second option is better because it helps the model learn how to adjust the representations better with respect to the given resolution. Since the results purely are empirical, a few more experiments such as analyzing the cross-channel interaction would have been even better. It is worth noting that elements like Squeeze and Excitation (SE) blocks, Global Context (GC) blocks also add a few parameters to an existing network but they are known to help a network process information in systematic ways to improve the overall performance. Notes To impose shape bias inside the vision models, Geirhos et al. trained them with a combination of natural and stylized images. It might be interesting to investigate if this learnable resizing module could achieve something similar as the outputs seem to discard the texture information. The resizer module can handle arbitrary resolutions and aspect ratios which is very important for tasks like object detection and segmentation. There is another closely related topic on adaptive image resizing that attempts to resize images/feature maps adaptively during training. EfficientV2 uses this idea. Implementing the MIRNet architecture for low-light image enhancement. Introduction With the goal of recovering high-quality image content from its degraded version, image restoration enjoys numerous applications, such as in photography, security, medical imaging, and remote sensing. In this example, we implement the MIRNet model for low-light image enhancement, a fully-convolutional architecture that learns an enriched set of features that combines contextual information from multiple scales, while simultaneously preserving the high-resolution spatial details. References: Learning Enriched Features for Real Image Restoration and Enhancement The Retinex Theory of Color Vision Two deterministic half-quadratic regularization algorithms for computed imaging Downloading LOLDataset The LoL Dataset has been created for low-light image enhancement. It provides 485 images for training and 15 for testing. Each image pair in the dataset consists of a low-light input image and its corresponding well-exposed reference image. import os import cv2 import random import numpy as np from glob import glob from PIL import Image, ImageOps import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers !gdown https://drive.google.com/uc?id=1DdGIJ4PZPlF2ikl8mNM9V-PdVxVLbQi6 !unzip -q lol_dataset.zip Downloading... From: https://drive.google.com/uc?id=1DdGIJ4PZPlF2ikl8mNM9V-PdVxVLbQi6 To: /content/keras-io/scripts/tmp_2614641/lol_dataset.zip 347MB [00:03, 108MB/s] Creating a TensorFlow Dataset We use 300 image pairs from the LoL Dataset's training set for training, and we use the remaining 185 image pairs for validation. We generate random crops of size 128 x 128 from the image pairs to be used for both training and validation. random.seed(10) IMAGE_SIZE = 128 BATCH_SIZE = 4 MAX_TRAIN_IMAGES = 300 def read_image(image_path): image = tf.io.read_file(image_path) image = tf.image.decode_png(image, channels=3) image.set_shape([None, None, 3]) image = tf.cast(image, dtype=tf.float32) / 255.0 return image def random_crop(low_image, enhanced_image): low_image_shape = tf.shape(low_image)[:2] low_w = tf.random.uniform( shape=(), maxval=low_image_shape[1] - IMAGE_SIZE + 1, dtype=tf.int32 ) low_h = tf.random.uniform( shape=(), maxval=low_image_shape[0] - IMAGE_SIZE + 1, dtype=tf.int32 ) enhanced_w = low_w enhanced_h = low_h low_image_cropped = low_image[ low_h : low_h + IMAGE_SIZE, low_w : low_w + IMAGE_SIZE ] enhanced_image_cropped = enhanced_image[ enhanced_h : enhanced_h + IMAGE_SIZE, enhanced_w : enhanced_w + IMAGE_SIZE ] return low_image_cropped, enhanced_image_cropped def load_data(low_light_image_path, enhanced_image_path): low_light_image = read_image(low_light_image_path) enhanced_image = read_image(enhanced_image_path) low_light_image, enhanced_image = random_crop(low_light_image, enhanced_image) return low_light_image, enhanced_image def get_dataset(low_light_images, enhanced_images): dataset = tf.data.Dataset.from_tensor_slices((low_light_images, enhanced_images)) dataset = dataset.map(load_data, num_parallel_calls=tf.data.AUTOTUNE) dataset = dataset.batch(BATCH_SIZE, drop_remainder=True) return dataset train_low_light_images = sorted(glob(\"./lol_dataset/our485/low/*\"))[:MAX_TRAIN_IMAGES] train_enhanced_images = sorted(glob(\"./lol_dataset/our485/high/*\"))[:MAX_TRAIN_IMAGES] val_low_light_images = sorted(glob(\"./lol_dataset/our485/low/*\"))[MAX_TRAIN_IMAGES:] val_enhanced_images = sorted(glob(\"./lol_dataset/our485/high/*\"))[MAX_TRAIN_IMAGES:] test_low_light_images = sorted(glob(\"./lol_dataset/eval15/low/*\")) test_enhanced_images = sorted(glob(\"./lol_dataset/eval15/high/*\")) train_dataset = get_dataset(train_low_light_images, train_enhanced_images) val_dataset = get_dataset(val_low_light_images, val_enhanced_images) print(\"Train Dataset:\", train_dataset) print(\"Val Dataset:\", val_dataset) Train Dataset: Val Dataset: MIRNet Model Here are the main features of the MIRNet model: A feature extraction model that computes a complementary set of features across multiple spatial scales, while maintaining the original high-resolution features to preserve precise spatial details. A regularly repeated mechanism for information exchange, where the features across multi-resolution branches are progressively fused together for improved representation learning. A new approach to fuse multi-scale features using a selective kernel network that dynamically combines variable receptive fields and faithfully preserves the original feature information at each spatial resolution. A recursive residual design that progressively breaks down the input signal in order to simplify the overall learning process, and allows the construction of very deep networks. Selective Kernel Feature Fusion The Selective Kernel Feature Fusion or SKFF module performs dynamic adjustment of receptive fields via two operations: Fuse and Select. The Fuse operator generates global feature descriptors by combining the information from multi-resolution streams. The Select operator uses these descriptors to recalibrate the feature maps (of different streams) followed by their aggregation. Fuse: The SKFF receives inputs from three parallel convolution streams carrying different scales of information. We first combine these multi-scale features using an element-wise sum, on which we apply Global Average Pooling (GAP) across the spatial dimension. Next, we apply a channel- downscaling convolution layer to generate a compact feature representation which passes through three parallel channel-upscaling convolution layers (one for each resolution stream) and provides us with three feature descriptors. Select: This operator applies the softmax function to the feature descriptors to obtain the corresponding activations that are used to adaptively recalibrate multi-scale feature maps. The aggregated features are defined as the sum of product of the corresponding multi-scale feature and the feature descriptor. def selective_kernel_feature_fusion( multi_scale_feature_1, multi_scale_feature_2, multi_scale_feature_3 ): channels = list(multi_scale_feature_1.shape)[-1] combined_feature = layers.Add()( [multi_scale_feature_1, multi_scale_feature_2, multi_scale_feature_3] ) gap = layers.GlobalAveragePooling2D()(combined_feature) channel_wise_statistics = tf.reshape(gap, shape=(-1, 1, 1, channels)) compact_feature_representation = layers.Conv2D( filters=channels // 8, kernel_size=(1, 1), activation=\"relu\" )(channel_wise_statistics) feature_descriptor_1 = layers.Conv2D( channels, kernel_size=(1, 1), activation=\"softmax\" )(compact_feature_representation) feature_descriptor_2 = layers.Conv2D( channels, kernel_size=(1, 1), activation=\"softmax\" )(compact_feature_representation) feature_descriptor_3 = layers.Conv2D( channels, kernel_size=(1, 1), activation=\"softmax\" )(compact_feature_representation) feature_1 = multi_scale_feature_1 * feature_descriptor_1 feature_2 = multi_scale_feature_2 * feature_descriptor_2 feature_3 = multi_scale_feature_3 * feature_descriptor_3 aggregated_feature = layers.Add()([feature_1, feature_2, feature_3]) return aggregated_feature Dual Attention Unit The Dual Attention Unit or DAU is used to extract features in the convolutional streams. While the SKFF block fuses information across multi-resolution branches, we also need a mechanism to share information within a feature tensor, both along the spatial and the channel dimensions which is done by the DAU block. The DAU suppresses less useful features and only allows more informative ones to pass further. This feature recalibration is achieved by using Channel Attention and Spatial Attention mechanisms. The Channel Attention branch exploits the inter-channel relationships of the convolutional feature maps by applying squeeze and excitation operations. Given a feature map, the squeeze operation applies Global Average Pooling across spatial dimensions to encode global context, thus yielding a feature descriptor. The excitation operator passes this feature descriptor through two convolutional layers followed by the sigmoid gating and generates activations. Finally, the output of Channel Attention branch is obtained by rescaling the input feature map with the output activations. The Spatial Attention branch is designed to exploit the inter-spatial dependencies of convolutional features. The goal of Spatial Attention is to generate a spatial attention map and use it to recalibrate the incoming features. To generate the spatial attention map, the Spatial Attention branch first independently applies Global Average Pooling and Max Pooling operations on input features along the channel dimensions and concatenates the outputs to form a resultant feature map which is then passed through a convolution and sigmoid activation to obtain the spatial attention map. This spatial attention map is then used to rescale the input feature map. def spatial_attention_block(input_tensor): average_pooling = tf.reduce_max(input_tensor, axis=-1) average_pooling = tf.expand_dims(average_pooling, axis=-1) max_pooling = tf.reduce_mean(input_tensor, axis=-1) max_pooling = tf.expand_dims(max_pooling, axis=-1) concatenated = layers.Concatenate(axis=-1)([average_pooling, max_pooling]) feature_map = layers.Conv2D(1, kernel_size=(1, 1))(concatenated) feature_map = tf.nn.sigmoid(feature_map) return input_tensor * feature_map def channel_attention_block(input_tensor): channels = list(input_tensor.shape)[-1] average_pooling = layers.GlobalAveragePooling2D()(input_tensor) feature_descriptor = tf.reshape(average_pooling, shape=(-1, 1, 1, channels)) feature_activations = layers.Conv2D( filters=channels // 8, kernel_size=(1, 1), activation=\"relu\" )(feature_descriptor) feature_activations = layers.Conv2D( filters=channels, kernel_size=(1, 1), activation=\"sigmoid\" )(feature_activations) return input_tensor * feature_activations def dual_attention_unit_block(input_tensor): channels = list(input_tensor.shape)[-1] feature_map = layers.Conv2D( channels, kernel_size=(3, 3), padding=\"same\", activation=\"relu\" )(input_tensor) feature_map = layers.Conv2D(channels, kernel_size=(3, 3), padding=\"same\")( feature_map ) channel_attention = channel_attention_block(feature_map) spatial_attention = spatial_attention_block(feature_map) concatenation = layers.Concatenate(axis=-1)([channel_attention, spatial_attention]) concatenation = layers.Conv2D(channels, kernel_size=(1, 1))(concatenation) return layers.Add()([input_tensor, concatenation]) Multi-Scale Residual Block The Multi-Scale Residual Block is capable of generating a spatially-precise output by maintaining high-resolution representations, while receiving rich contextual information from low-resolutions. The MRB consists of multiple (three in this paper) fully-convolutional streams connected in parallel. It allows information exchange across parallel streams in order to consolidate the high-resolution features with the help of low-resolution features, and vice versa. The MIRNet employs a recursive residual design (with skip connections) to ease the flow of information during the learning process. In order to maintain the residual nature of our architecture, residual resizing modules are used to perform downsampling and upsampling operations that are used in the Multi-scale Residual Block. # Recursive Residual Modules def down_sampling_module(input_tensor): channels = list(input_tensor.shape)[-1] main_branch = layers.Conv2D(channels, kernel_size=(1, 1), activation=\"relu\")( input_tensor ) main_branch = layers.Conv2D( channels, kernel_size=(3, 3), padding=\"same\", activation=\"relu\" )(main_branch) main_branch = layers.MaxPooling2D()(main_branch) main_branch = layers.Conv2D(channels * 2, kernel_size=(1, 1))(main_branch) skip_branch = layers.MaxPooling2D()(input_tensor) skip_branch = layers.Conv2D(channels * 2, kernel_size=(1, 1))(skip_branch) return layers.Add()([skip_branch, main_branch]) def up_sampling_module(input_tensor): channels = list(input_tensor.shape)[-1] main_branch = layers.Conv2D(channels, kernel_size=(1, 1), activation=\"relu\")( input_tensor ) main_branch = layers.Conv2D( channels, kernel_size=(3, 3), padding=\"same\", activation=\"relu\" )(main_branch) main_branch = layers.UpSampling2D()(main_branch) main_branch = layers.Conv2D(channels // 2, kernel_size=(1, 1))(main_branch) skip_branch = layers.UpSampling2D()(input_tensor) skip_branch = layers.Conv2D(channels // 2, kernel_size=(1, 1))(skip_branch) return layers.Add()([skip_branch, main_branch]) # MRB Block def multi_scale_residual_block(input_tensor, channels): # features level1 = input_tensor level2 = down_sampling_module(input_tensor) level3 = down_sampling_module(level2) # DAU level1_dau = dual_attention_unit_block(level1) level2_dau = dual_attention_unit_block(level2) level3_dau = dual_attention_unit_block(level3) # SKFF level1_skff = selective_kernel_feature_fusion( level1_dau, up_sampling_module(level2_dau), up_sampling_module(up_sampling_module(level3_dau)), ) level2_skff = selective_kernel_feature_fusion( down_sampling_module(level1_dau), level2_dau, up_sampling_module(level3_dau) ) level3_skff = selective_kernel_feature_fusion( down_sampling_module(down_sampling_module(level1_dau)), down_sampling_module(level2_dau), level3_dau, ) # DAU 2 level1_dau_2 = dual_attention_unit_block(level1_skff) level2_dau_2 = up_sampling_module((dual_attention_unit_block(level2_skff))) level3_dau_2 = up_sampling_module( up_sampling_module(dual_attention_unit_block(level3_skff)) ) # SKFF 2 skff_ = selective_kernel_feature_fusion(level1_dau_2, level3_dau_2, level3_dau_2) conv = layers.Conv2D(channels, kernel_size=(3, 3), padding=\"same\")(skff_) return layers.Add()([input_tensor, conv]) MIRNet Model def recursive_residual_group(input_tensor, num_mrb, channels): conv1 = layers.Conv2D(channels, kernel_size=(3, 3), padding=\"same\")(input_tensor) for _ in range(num_mrb): conv1 = multi_scale_residual_block(conv1, channels) conv2 = layers.Conv2D(channels, kernel_size=(3, 3), padding=\"same\")(conv1) return layers.Add()([conv2, input_tensor]) def mirnet_model(num_rrg, num_mrb, channels): input_tensor = keras.Input(shape=[None, None, 3]) x1 = layers.Conv2D(channels, kernel_size=(3, 3), padding=\"same\")(input_tensor) for _ in range(num_rrg): x1 = recursive_residual_group(x1, num_mrb, channels) conv = layers.Conv2D(3, kernel_size=(3, 3), padding=\"same\")(x1) output_tensor = layers.Add()([input_tensor, conv]) return keras.Model(input_tensor, output_tensor) model = mirnet_model(num_rrg=3, num_mrb=2, channels=64) Training We train MIRNet using Charbonnier Loss as the loss function and Adam Optimizer with a learning rate of 1e-4. We use Peak Signal Noise Ratio or PSNR as a metric which is an expression for the ratio between the maximum possible value (power) of a signal and the power of distorting noise that affects the quality of its representation. def charbonnier_loss(y_true, y_pred): return tf.reduce_mean(tf.sqrt(tf.square(y_true - y_pred) + tf.square(1e-3))) def peak_signal_noise_ratio(y_true, y_pred): return tf.image.psnr(y_pred, y_true, max_val=255.0) optimizer = keras.optimizers.Adam(learning_rate=1e-4) model.compile( optimizer=optimizer, loss=charbonnier_loss, metrics=[peak_signal_noise_ratio] ) history = model.fit( train_dataset, validation_data=val_dataset, epochs=50, callbacks=[ keras.callbacks.ReduceLROnPlateau( monitor=\"val_peak_signal_noise_ratio\", factor=0.5, patience=5, verbose=1, min_delta=1e-7, mode=\"max\", ) ], ) plt.plot(history.history[\"loss\"], label=\"train_loss\") plt.plot(history.history[\"val_loss\"], label=\"val_loss\") plt.xlabel(\"Epochs\") plt.ylabel(\"Loss\") plt.title(\"Train and Validation Losses Over Epochs\", fontsize=14) plt.legend() plt.grid() plt.show() plt.plot(history.history[\"peak_signal_noise_ratio\"], label=\"train_psnr\") plt.plot(history.history[\"val_peak_signal_noise_ratio\"], label=\"val_psnr\") plt.xlabel(\"Epochs\") plt.ylabel(\"PSNR\") plt.title(\"Train and Validation PSNR Over Epochs\", fontsize=14) plt.legend() plt.grid() plt.show() Epoch 1/50 75/75 [==============================] - 109s 731ms/step - loss: 0.2125 - peak_signal_noise_ratio: 62.0458 - val_loss: 0.1592 - val_peak_signal_noise_ratio: 64.1833 Epoch 2/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1764 - peak_signal_noise_ratio: 63.1356 - val_loss: 0.1257 - val_peak_signal_noise_ratio: 65.6498 Epoch 3/50 75/75 [==============================] - 49s 652ms/step - loss: 0.1724 - peak_signal_noise_ratio: 63.3172 - val_loss: 0.1245 - val_peak_signal_noise_ratio: 65.6902 Epoch 4/50 75/75 [==============================] - 49s 653ms/step - loss: 0.1670 - peak_signal_noise_ratio: 63.4917 - val_loss: 0.1206 - val_peak_signal_noise_ratio: 65.8893 Epoch 5/50 75/75 [==============================] - 49s 653ms/step - loss: 0.1651 - peak_signal_noise_ratio: 63.6555 - val_loss: 0.1333 - val_peak_signal_noise_ratio: 65.6338 Epoch 6/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1572 - peak_signal_noise_ratio: 64.1984 - val_loss: 0.1142 - val_peak_signal_noise_ratio: 66.7711 Epoch 7/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1592 - peak_signal_noise_ratio: 64.0062 - val_loss: 0.1205 - val_peak_signal_noise_ratio: 66.1075 Epoch 8/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1493 - peak_signal_noise_ratio: 64.4675 - val_loss: 0.1170 - val_peak_signal_noise_ratio: 66.1355 Epoch 9/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1446 - peak_signal_noise_ratio: 64.7416 - val_loss: 0.1301 - val_peak_signal_noise_ratio: 66.0207 Epoch 10/50 75/75 [==============================] - 49s 655ms/step - loss: 0.1539 - peak_signal_noise_ratio: 64.3999 - val_loss: 0.1220 - val_peak_signal_noise_ratio: 66.7203 Epoch 11/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1451 - peak_signal_noise_ratio: 64.7352 - val_loss: 0.1219 - val_peak_signal_noise_ratio: 66.3140 Epoch 00011: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-05. Epoch 12/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1492 - peak_signal_noise_ratio: 64.7238 - val_loss: 0.1204 - val_peak_signal_noise_ratio: 66.4726 Epoch 13/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1456 - peak_signal_noise_ratio: 64.9666 - val_loss: 0.1109 - val_peak_signal_noise_ratio: 67.1270 Epoch 14/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1372 - peak_signal_noise_ratio: 65.3932 - val_loss: 0.1150 - val_peak_signal_noise_ratio: 66.9255 Epoch 15/50 75/75 [==============================] - 49s 650ms/step - loss: 0.1340 - peak_signal_noise_ratio: 65.5611 - val_loss: 0.1111 - val_peak_signal_noise_ratio: 67.2009 Epoch 16/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1377 - peak_signal_noise_ratio: 65.3355 - val_loss: 0.1140 - val_peak_signal_noise_ratio: 67.0495 Epoch 17/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1340 - peak_signal_noise_ratio: 65.6484 - val_loss: 0.1132 - val_peak_signal_noise_ratio: 67.0257 Epoch 18/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1360 - peak_signal_noise_ratio: 65.4871 - val_loss: 0.1070 - val_peak_signal_noise_ratio: 67.4185 Epoch 19/50 75/75 [==============================] - 49s 649ms/step - loss: 0.1349 - peak_signal_noise_ratio: 65.4856 - val_loss: 0.1112 - val_peak_signal_noise_ratio: 67.2248 Epoch 20/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1273 - peak_signal_noise_ratio: 66.0817 - val_loss: 0.1185 - val_peak_signal_noise_ratio: 67.0208 Epoch 21/50 75/75 [==============================] - 49s 656ms/step - loss: 0.1393 - peak_signal_noise_ratio: 65.3710 - val_loss: 0.1102 - val_peak_signal_noise_ratio: 67.0362 Epoch 22/50 75/75 [==============================] - 49s 653ms/step - loss: 0.1326 - peak_signal_noise_ratio: 65.8781 - val_loss: 0.1059 - val_peak_signal_noise_ratio: 67.4949 Epoch 23/50 75/75 [==============================] - 49s 653ms/step - loss: 0.1260 - peak_signal_noise_ratio: 66.1770 - val_loss: 0.1187 - val_peak_signal_noise_ratio: 66.6312 Epoch 24/50 75/75 [==============================] - 49s 650ms/step - loss: 0.1331 - peak_signal_noise_ratio: 65.8160 - val_loss: 0.1075 - val_peak_signal_noise_ratio: 67.2668 Epoch 25/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1288 - peak_signal_noise_ratio: 66.0734 - val_loss: 0.1027 - val_peak_signal_noise_ratio: 67.9508 Epoch 26/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1306 - peak_signal_noise_ratio: 66.0349 - val_loss: 0.1076 - val_peak_signal_noise_ratio: 67.3821 Epoch 27/50 75/75 [==============================] - 49s 655ms/step - loss: 0.1356 - peak_signal_noise_ratio: 65.7978 - val_loss: 0.1079 - val_peak_signal_noise_ratio: 67.4785 Epoch 28/50 75/75 [==============================] - 49s 655ms/step - loss: 0.1270 - peak_signal_noise_ratio: 66.2681 - val_loss: 0.1116 - val_peak_signal_noise_ratio: 67.3327 Epoch 29/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1297 - peak_signal_noise_ratio: 66.0506 - val_loss: 0.1057 - val_peak_signal_noise_ratio: 67.5432 Epoch 30/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1275 - peak_signal_noise_ratio: 66.3542 - val_loss: 0.1034 - val_peak_signal_noise_ratio: 67.4624 Epoch 00030: ReduceLROnPlateau reducing learning rate to 2.499999936844688e-05. Epoch 31/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1258 - peak_signal_noise_ratio: 66.2724 - val_loss: 0.1066 - val_peak_signal_noise_ratio: 67.5729 Epoch 32/50 75/75 [==============================] - 49s 653ms/step - loss: 0.1153 - peak_signal_noise_ratio: 67.0384 - val_loss: 0.1064 - val_peak_signal_noise_ratio: 67.4336 Epoch 33/50 75/75 [==============================] - 49s 653ms/step - loss: 0.1189 - peak_signal_noise_ratio: 66.7662 - val_loss: 0.1062 - val_peak_signal_noise_ratio: 67.5128 Epoch 34/50 75/75 [==============================] - 49s 654ms/step - loss: 0.1159 - peak_signal_noise_ratio: 66.9257 - val_loss: 0.1003 - val_peak_signal_noise_ratio: 67.8672 Epoch 35/50 75/75 [==============================] - 49s 653ms/step - loss: 0.1191 - peak_signal_noise_ratio: 66.7690 - val_loss: 0.1043 - val_peak_signal_noise_ratio: 67.4840 Epoch 00035: ReduceLROnPlateau reducing learning rate to 1.249999968422344e-05. Epoch 36/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1158 - peak_signal_noise_ratio: 67.0264 - val_loss: 0.1057 - val_peak_signal_noise_ratio: 67.6526 Epoch 37/50 75/75 [==============================] - 49s 652ms/step - loss: 0.1128 - peak_signal_noise_ratio: 67.1950 - val_loss: 0.1104 - val_peak_signal_noise_ratio: 67.1770 Epoch 38/50 75/75 [==============================] - 49s 652ms/step - loss: 0.1200 - peak_signal_noise_ratio: 66.7623 - val_loss: 0.1048 - val_peak_signal_noise_ratio: 67.7003 Epoch 39/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1112 - peak_signal_noise_ratio: 67.3895 - val_loss: 0.1031 - val_peak_signal_noise_ratio: 67.6530 Epoch 40/50 75/75 [==============================] - 49s 650ms/step - loss: 0.1125 - peak_signal_noise_ratio: 67.1694 - val_loss: 0.1034 - val_peak_signal_noise_ratio: 67.6437 Epoch 00040: ReduceLROnPlateau reducing learning rate to 6.24999984211172e-06. Epoch 41/50 75/75 [==============================] - 49s 650ms/step - loss: 0.1131 - peak_signal_noise_ratio: 67.2471 - val_loss: 0.1152 - val_peak_signal_noise_ratio: 66.8625 Epoch 42/50 75/75 [==============================] - 49s 650ms/step - loss: 0.1069 - peak_signal_noise_ratio: 67.5794 - val_loss: 0.1119 - val_peak_signal_noise_ratio: 67.1944 Epoch 43/50 75/75 [==============================] - 49s 651ms/step - loss: 0.1118 - peak_signal_noise_ratio: 67.2779 - val_loss: 0.1147 - val_peak_signal_noise_ratio: 66.9731 Epoch 44/50 75/75 [==============================] - 48s 647ms/step - loss: 0.1101 - peak_signal_noise_ratio: 67.2777 - val_loss: 0.1107 - val_peak_signal_noise_ratio: 67.2580 Epoch 45/50 75/75 [==============================] - 49s 649ms/step - loss: 0.1076 - peak_signal_noise_ratio: 67.6359 - val_loss: 0.1103 - val_peak_signal_noise_ratio: 67.2720 Epoch 00045: ReduceLROnPlateau reducing learning rate to 3.12499992105586e-06. Epoch 46/50 75/75 [==============================] - 49s 648ms/step - loss: 0.1066 - peak_signal_noise_ratio: 67.4869 - val_loss: 0.1077 - val_peak_signal_noise_ratio: 67.4986 Epoch 47/50 75/75 [==============================] - 49s 649ms/step - loss: 0.1072 - peak_signal_noise_ratio: 67.4890 - val_loss: 0.1140 - val_peak_signal_noise_ratio: 67.1755 Epoch 48/50 75/75 [==============================] - 49s 649ms/step - loss: 0.1065 - peak_signal_noise_ratio: 67.6796 - val_loss: 0.1091 - val_peak_signal_noise_ratio: 67.3442 Epoch 49/50 75/75 [==============================] - 49s 648ms/step - loss: 0.1098 - peak_signal_noise_ratio: 67.3909 - val_loss: 0.1082 - val_peak_signal_noise_ratio: 67.4616 Epoch 50/50 75/75 [==============================] - 49s 648ms/step - loss: 0.1090 - peak_signal_noise_ratio: 67.5139 - val_loss: 0.1124 - val_peak_signal_noise_ratio: 67.1488 Epoch 00050: ReduceLROnPlateau reducing learning rate to 1.56249996052793e-06. png png Inference def plot_results(images, titles, figure_size=(12, 12)): fig = plt.figure(figsize=figure_size) for i in range(len(images)): fig.add_subplot(1, len(images), i + 1).set_title(titles[i]) _ = plt.imshow(images[i]) plt.axis(\"off\") plt.show() def infer(original_image): image = keras.preprocessing.image.img_to_array(original_image) image = image.astype(\"float32\") / 255.0 image = np.expand_dims(image, axis=0) output = model.predict(image) output_image = output[0] * 255.0 output_image = output_image.clip(0, 255) output_image = output_image.reshape( (np.shape(output_image)[0], np.shape(output_image)[1], 3) ) output_image = Image.fromarray(np.uint8(output_image)) original_image = Image.fromarray(np.uint8(original_image)) return output_image Inference on Test Images We compare the test images from LOLDataset enhanced by MIRNet with images enhanced via the PIL.ImageOps.autocontrast() function. for low_light_image in random.sample(test_low_light_images, 6): original_image = Image.open(low_light_image) enhanced_image = infer(original_image) plot_results( [original_image, ImageOps.autocontrast(original_image), enhanced_image], [\"Original\", \"PIL Autocontrast\", \"MIRNet Enhanced\"], (20, 12), ) png png png png png png Implementing Masked Autoencoders for self-supervised pretraining. Introduction In deep learning, models with growing capacity and capability can easily overfit on large datasets (ImageNet-1K). In the field of natural language processing, the appetite for data has been successfully addressed by self-supervised pretraining. In the academic paper Masked Autoencoders Are Scalable Vision Learners by He et. al. the authors propose a simple yet effective method to pretrain large vision models (here ViT Huge). Inspired from the pretraining algorithm of BERT (Devlin et al.), they mask patches of an image and, through an autoencoder predict the masked patches. In the spirit of \"masked language modeling\", this pretraining task could be referred to as \"masked image modeling\". In this example, we implement Masked Autoencoders Are Scalable Vision Learners with the CIFAR-10 dataset. After pretraining a scaled down version of ViT, we also implement the linear evaluation pipeline on CIFAR-10. This implementation covers (MAE refers to Masked Autoencoder): The masking algorithm MAE encoder MAE decoder Evaluation with linear probing As a reference, we reuse some of the code presented in this example. Imports This example requires TensorFlow Addons, which can be installed using the following command: pip install -U tensorflow-addons from tensorflow.keras import layers import tensorflow_addons as tfa from tensorflow import keras import tensorflow as tf import matplotlib.pyplot as plt import numpy as np import random # Setting seeds for reproducibility. SEED = 42 keras.utils.set_random_seed(SEED) Hyperparameters for pretraining Please feel free to change the hyperparameters and check your results. The best way to get an intuition about the architecture is to experiment with it. Our hyperparameters are heavily inspired by the design guidelines laid out by the authors in the original paper. # DATA BUFFER_SIZE = 1024 BATCH_SIZE = 256 AUTO = tf.data.AUTOTUNE INPUT_SHAPE = (32, 32, 3) NUM_CLASSES = 10 # OPTIMIZER LEARNING_RATE = 5e-3 WEIGHT_DECAY = 1e-4 # PRETRAINING EPOCHS = 100 # AUGMENTATION IMAGE_SIZE = 48 # We will resize input images to this size. PATCH_SIZE = 6 # Size of the patches to be extracted from the input images. NUM_PATCHES = (IMAGE_SIZE // PATCH_SIZE) ** 2 MASK_PROPORTION = 0.75 # We have found 75% masking to give us the best results. # ENCODER and DECODER LAYER_NORM_EPS = 1e-6 ENC_PROJECTION_DIM = 128 DEC_PROJECTION_DIM = 64 ENC_NUM_HEADS = 4 ENC_LAYERS = 6 DEC_NUM_HEADS = 4 DEC_LAYERS = ( 2 # The decoder is lightweight but should be reasonably deep for reconstruction. ) ENC_TRANSFORMER_UNITS = [ ENC_PROJECTION_DIM * 2, ENC_PROJECTION_DIM, ] # Size of the transformer layers. DEC_TRANSFORMER_UNITS = [ DEC_PROJECTION_DIM * 2, DEC_PROJECTION_DIM, ] Load and prepare the CIFAR-10 dataset (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() (x_train, y_train), (x_val, y_val) = ( (x_train[:40000], y_train[:40000]), (x_train[40000:], y_train[40000:]), ) print(f\"Training samples: {len(x_train)}\") print(f\"Validation samples: {len(x_val)}\") print(f\"Testing samples: {len(x_test)}\") train_ds = tf.data.Dataset.from_tensor_slices(x_train) train_ds = train_ds.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(AUTO) val_ds = tf.data.Dataset.from_tensor_slices(x_val) val_ds = val_ds.batch(BATCH_SIZE).prefetch(AUTO) test_ds = tf.data.Dataset.from_tensor_slices(x_test) test_ds = test_ds.batch(BATCH_SIZE).prefetch(AUTO) Training samples: 40000 Validation samples: 10000 Testing samples: 10000 2021-11-24 01:10:52.088318: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. 2021-11-24 01:10:54.356762: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 38444 MB memory: -> device: 0, name: A100-SXM4-40GB, pci bus id: 0000:00:04.0, compute capability: 8.0 Data augmentation In previous self-supervised pretraining methodologies (SimCLR alike), we have noticed that the data augmentation pipeline plays an important role. On the other hand the authors of this paper point out that Masked Autoencoders do not rely on augmentations. They propose a simple augmentation pipeline of: Resizing Random cropping (fixed-sized or random sized) Random horizontal flipping def get_train_augmentation_model(): model = keras.Sequential( [ layers.Rescaling(1 / 255.0), layers.Resizing(INPUT_SHAPE[0] + 20, INPUT_SHAPE[0] + 20), layers.RandomCrop(IMAGE_SIZE, IMAGE_SIZE), layers.RandomFlip(\"horizontal\"), ], name=\"train_data_augmentation\", ) return model def get_test_augmentation_model(): model = keras.Sequential( [layers.Rescaling(1 / 255.0), layers.Resizing(IMAGE_SIZE, IMAGE_SIZE),], name=\"test_data_augmentation\", ) return model A layer for extracting patches from images This layer takes images as input and divides them into patches. The layer also includes two utility method: show_patched_image -- Takes a batch of images and its corresponding patches to plot a random pair of image and patches. reconstruct_from_patch -- Takes a single instance of patches and stitches them together into the original image. class Patches(layers.Layer): def __init__(self, patch_size=PATCH_SIZE, **kwargs): super().__init__(**kwargs) self.patch_size = patch_size # Assuming the image has three channels each patch would be # of size (patch_size, patch_size, 3). self.resize = layers.Reshape((-1, patch_size * patch_size * 3)) def call(self, images): # Create patches from the input images patches = tf.image.extract_patches( images=images, sizes=[1, self.patch_size, self.patch_size, 1], strides=[1, self.patch_size, self.patch_size, 1], rates=[1, 1, 1, 1], padding=\"VALID\", ) # Reshape the patches to (batch, num_patches, patch_area) and return it. patches = self.resize(patches) return patches def show_patched_image(self, images, patches): # This is a utility function which accepts a batch of images and its # corresponding patches and help visualize one image and its patches # side by side. idx = np.random.choice(patches.shape[0]) print(f\"Index selected: {idx}.\") plt.figure(figsize=(4, 4)) plt.imshow(keras.utils.array_to_img(images[idx])) plt.axis(\"off\") plt.show() n = int(np.sqrt(patches.shape[1])) plt.figure(figsize=(4, 4)) for i, patch in enumerate(patches[idx]): ax = plt.subplot(n, n, i + 1) patch_img = tf.reshape(patch, (self.patch_size, self.patch_size, 3)) plt.imshow(keras.utils.img_to_array(patch_img)) plt.axis(\"off\") plt.show() # Return the index chosen to validate it outside the method. return idx # taken from https://stackoverflow.com/a/58082878/10319735 def reconstruct_from_patch(self, patch): # This utility function takes patches from a *single* image and # reconstructs it back into the image. This is useful for the train # monitor callback. num_patches = patch.shape[0] n = int(np.sqrt(num_patches)) patch = tf.reshape(patch, (num_patches, self.patch_size, self.patch_size, 3)) rows = tf.split(patch, n, axis=0) rows = [tf.concat(tf.unstack(x), axis=1) for x in rows] reconstructed = tf.concat(rows, axis=0) return reconstructed Let's visualize the image patches. # Get a batch of images. image_batch = next(iter(train_ds)) # Augment the images. augmentation_model = get_train_augmentation_model() augmented_images = augmentation_model(image_batch) # Define the patch layer. patch_layer = Patches() # Get the patches from the batched images. patches = patch_layer(images=augmented_images) # Now pass the images and the corresponding patches # to the `show_patched_image` method. random_index = patch_layer.show_patched_image(images=augmented_images, patches=patches) # Chose the same chose image and try reconstructing the patches # into the original image. image = patch_layer.reconstruct_from_patch(patches[random_index]) plt.imshow(image) plt.axis(\"off\") plt.show() Index selected: 102. png png png Patch encoding with masking Quoting the paper Following ViT, we divide an image into regular non-overlapping patches. Then we sample a subset of patches and mask (i.e., remove) the remaining ones. Our sampling strategy is straightforward: we sample random patches without replacement, following a uniform distribution. We simply refer to this as “random sampling”. This layer includes masking and encoding the patches. The utility methods of the layer are: get_random_indices -- Provides the mask and unmask indices. generate_masked_image -- Takes patches and unmask indices, results in a random masked image. This is an essential utility method for our training monitor callback (defined later). class PatchEncoder(layers.Layer): def __init__( self, patch_size=PATCH_SIZE, projection_dim=ENC_PROJECTION_DIM, mask_proportion=MASK_PROPORTION, downstream=False, **kwargs, ): super().__init__(**kwargs) self.patch_size = patch_size self.projection_dim = projection_dim self.mask_proportion = mask_proportion self.downstream = downstream # This is a trainable mask token initialized randomly from a normal # distribution. self.mask_token = tf.Variable( tf.random.normal([1, patch_size * patch_size * 3]), trainable=True ) def build(self, input_shape): (_, self.num_patches, self.patch_area) = input_shape # Create the projection layer for the patches. self.projection = layers.Dense(units=self.projection_dim) # Create the positional embedding layer. self.position_embedding = layers.Embedding( input_dim=self.num_patches, output_dim=self.projection_dim ) # Number of patches that will be masked. self.num_mask = int(self.mask_proportion * self.num_patches) def call(self, patches): # Get the positional embeddings. batch_size = tf.shape(patches)[0] positions = tf.range(start=0, limit=self.num_patches, delta=1) pos_embeddings = self.position_embedding(positions[tf.newaxis, ...]) pos_embeddings = tf.tile( pos_embeddings, [batch_size, 1, 1] ) # (B, num_patches, projection_dim) # Embed the patches. patch_embeddings = ( self.projection(patches) + pos_embeddings ) # (B, num_patches, projection_dim) if self.downstream: return patch_embeddings else: mask_indices, unmask_indices = self.get_random_indices(batch_size) # The encoder input is the unmasked patch embeddings. Here we gather # all the patches that should be unmasked. unmasked_embeddings = tf.gather( patch_embeddings, unmask_indices, axis=1, batch_dims=1 ) # (B, unmask_numbers, projection_dim) # Get the unmasked and masked position embeddings. We will need them # for the decoder. unmasked_positions = tf.gather( pos_embeddings, unmask_indices, axis=1, batch_dims=1 ) # (B, unmask_numbers, projection_dim) masked_positions = tf.gather( pos_embeddings, mask_indices, axis=1, batch_dims=1 ) # (B, mask_numbers, projection_dim) # Repeat the mask token number of mask times. # Mask tokens replace the masks of the image. mask_tokens = tf.repeat(self.mask_token, repeats=self.num_mask, axis=0) mask_tokens = tf.repeat( mask_tokens[tf.newaxis, ...], repeats=batch_size, axis=0 ) # Get the masked embeddings for the tokens. masked_embeddings = self.projection(mask_tokens) + masked_positions return ( unmasked_embeddings, # Input to the encoder. masked_embeddings, # First part of input to the decoder. unmasked_positions, # Added to the encoder outputs. mask_indices, # The indices that were masked. unmask_indices, # The indices that were unmaksed. ) def get_random_indices(self, batch_size): # Create random indices from a uniform distribution and then split # it into mask and unmask indices. rand_indices = tf.argsort( tf.random.uniform(shape=(batch_size, self.num_patches)), axis=-1 ) mask_indices = rand_indices[:, : self.num_mask] unmask_indices = rand_indices[:, self.num_mask :] return mask_indices, unmask_indices def generate_masked_image(self, patches, unmask_indices): # Choose a random patch and it corresponding unmask index. idx = np.random.choice(patches.shape[0]) patch = patches[idx] unmask_index = unmask_indices[idx] # Build a numpy array of same shape as patch. new_patch = np.zeros_like(patch) # Iterate of the new_patch and plug the unmasked patches. count = 0 for i in range(unmask_index.shape[0]): new_patch[unmask_index[i]] = patch[unmask_index[i]] return new_patch, idx Let's see the masking process in action on a sample image. # Create the patch encoder layer. patch_encoder = PatchEncoder() # Get the embeddings and positions. ( unmasked_embeddings, masked_embeddings, unmasked_positions, mask_indices, unmask_indices, ) = patch_encoder(patches=patches) # Show a maksed patch image. new_patch, random_index = patch_encoder.generate_masked_image(patches, unmask_indices) plt.figure(figsize=(10, 10)) plt.subplot(1, 2, 1) img = patch_layer.reconstruct_from_patch(new_patch) plt.imshow(keras.utils.array_to_img(img)) plt.axis(\"off\") plt.title(\"Masked\") plt.subplot(1, 2, 2) img = augmented_images[random_index] plt.imshow(keras.utils.array_to_img(img)) plt.axis(\"off\") plt.title(\"Original\") plt.show() 2021-11-24 01:11:00.182447: I tensorflow/stream_executor/cuda/cuda_blas.cc:1774] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once. png MLP This serves as the fully connected feed forward network of the transformer architecture. def mlp(x, dropout_rate, hidden_units): for units in hidden_units: x = layers.Dense(units, activation=tf.nn.gelu)(x) x = layers.Dropout(dropout_rate)(x) return x MAE encoder The MAE encoder is ViT. The only point to note here is that the encoder outputs a layer normalized output. def create_encoder(num_heads=ENC_NUM_HEADS, num_layers=ENC_LAYERS): inputs = layers.Input((None, ENC_PROJECTION_DIM)) x = inputs for _ in range(num_layers): # Layer normalization 1. x1 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x) # Create a multi-head attention layer. attention_output = layers.MultiHeadAttention( num_heads=num_heads, key_dim=ENC_PROJECTION_DIM, dropout=0.1 )(x1, x1) # Skip connection 1. x2 = layers.Add()([attention_output, x]) # Layer normalization 2. x3 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x2) # MLP. x3 = mlp(x3, hidden_units=ENC_TRANSFORMER_UNITS, dropout_rate=0.1) # Skip connection 2. x = layers.Add()([x3, x2]) outputs = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x) return keras.Model(inputs, outputs, name=\"mae_encoder\") MAE decoder The authors point out that they use an asymmetric autoencoder model. They use a lightweight decoder that takes \"<10% computation per token vs. the encoder\". We are not specific with the \"<10% computation\" in our implementation but have used a smaller decoder (both in terms of depth and projection dimensions). def create_decoder( num_layers=DEC_LAYERS, num_heads=DEC_NUM_HEADS, image_size=IMAGE_SIZE ): inputs = layers.Input((NUM_PATCHES, ENC_PROJECTION_DIM)) x = layers.Dense(DEC_PROJECTION_DIM)(inputs) for _ in range(num_layers): # Layer normalization 1. x1 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x) # Create a multi-head attention layer. attention_output = layers.MultiHeadAttention( num_heads=num_heads, key_dim=DEC_PROJECTION_DIM, dropout=0.1 )(x1, x1) # Skip connection 1. x2 = layers.Add()([attention_output, x]) # Layer normalization 2. x3 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x2) # MLP. x3 = mlp(x3, hidden_units=DEC_TRANSFORMER_UNITS, dropout_rate=0.1) # Skip connection 2. x = layers.Add()([x3, x2]) x = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x) x = layers.Flatten()(x) pre_final = layers.Dense(units=image_size * image_size * 3, activation=\"sigmoid\")(x) outputs = layers.Reshape((image_size, image_size, 3))(pre_final) return keras.Model(inputs, outputs, name=\"mae_decoder\") MAE trainer This is the trainer module. We wrap the encoder and decoder inside of a tf.keras.Model subclass. This allows us to customize what happens in the model.fit() loop. class MaskedAutoencoder(keras.Model): def __init__( self, train_augmentation_model, test_augmentation_model, patch_layer, patch_encoder, encoder, decoder, **kwargs, ): super().__init__(**kwargs) self.train_augmentation_model = train_augmentation_model self.test_augmentation_model = test_augmentation_model self.patch_layer = patch_layer self.patch_encoder = patch_encoder self.encoder = encoder self.decoder = decoder def calculate_loss(self, images, test=False): # Augment the input images. if test: augmented_images = self.test_augmentation_model(images) else: augmented_images = self.train_augmentation_model(images) # Patch the augmented images. patches = self.patch_layer(augmented_images) # Encode the patches. ( unmasked_embeddings, masked_embeddings, unmasked_positions, mask_indices, unmask_indices, ) = self.patch_encoder(patches) # Pass the unmaksed patche to the encoder. encoder_outputs = self.encoder(unmasked_embeddings) # Create the decoder inputs. encoder_outputs = encoder_outputs + unmasked_positions decoder_inputs = tf.concat([encoder_outputs, masked_embeddings], axis=1) # Decode the inputs. decoder_outputs = self.decoder(decoder_inputs) decoder_patches = self.patch_layer(decoder_outputs) loss_patch = tf.gather(patches, mask_indices, axis=1, batch_dims=1) loss_output = tf.gather(decoder_patches, mask_indices, axis=1, batch_dims=1) # Compute the total loss. total_loss = self.compiled_loss(loss_patch, loss_output) return total_loss, loss_patch, loss_output def train_step(self, images): with tf.GradientTape() as tape: total_loss, loss_patch, loss_output = self.calculate_loss(images) # Apply gradients. train_vars = [ self.train_augmentation_model.trainable_variables, self.patch_layer.trainable_variables, self.patch_encoder.trainable_variables, self.encoder.trainable_variables, self.decoder.trainable_variables, ] grads = tape.gradient(total_loss, train_vars) tv_list = [] for (grad, var) in zip(grads, train_vars): for g, v in zip(grad, var): tv_list.append((g, v)) self.optimizer.apply_gradients(tv_list) # Report progress. self.compiled_metrics.update_state(loss_patch, loss_output) return {m.name: m.result() for m in self.metrics} def test_step(self, images): total_loss, loss_patch, loss_output = self.calculate_loss(images, test=True) # Update the trackers. self.compiled_metrics.update_state(loss_patch, loss_output) return {m.name: m.result() for m in self.metrics} Model initialization train_augmentation_model = get_train_augmentation_model() test_augmentation_model = get_test_augmentation_model() patch_layer = Patches() patch_encoder = PatchEncoder() encoder = create_encoder() decoder = create_decoder() mae_model = MaskedAutoencoder( train_augmentation_model=train_augmentation_model, test_augmentation_model=test_augmentation_model, patch_layer=patch_layer, patch_encoder=patch_encoder, encoder=encoder, decoder=decoder, ) Training callbacks Visualization callback # Taking a batch of test inputs to measure model's progress. test_images = next(iter(test_ds)) class TrainMonitor(keras.callbacks.Callback): def __init__(self, epoch_interval=None): self.epoch_interval = epoch_interval def on_epoch_end(self, epoch, logs=None): if self.epoch_interval and epoch % self.epoch_interval == 0: test_augmented_images = self.model.test_augmentation_model(test_images) test_patches = self.model.patch_layer(test_augmented_images) ( test_unmasked_embeddings, test_masked_embeddings, test_unmasked_positions, test_mask_indices, test_unmask_indices, ) = self.model.patch_encoder(test_patches) test_encoder_outputs = self.model.encoder(test_unmasked_embeddings) test_encoder_outputs = test_encoder_outputs + test_unmasked_positions test_decoder_inputs = tf.concat( [test_encoder_outputs, test_masked_embeddings], axis=1 ) test_decoder_outputs = self.model.decoder(test_decoder_inputs) # Show a maksed patch image. test_masked_patch, idx = self.model.patch_encoder.generate_masked_image( test_patches, test_unmask_indices ) print(f\"\nIdx chosen: {idx}\") original_image = test_augmented_images[idx] masked_image = self.model.patch_layer.reconstruct_from_patch( test_masked_patch ) reconstructed_image = test_decoder_outputs[idx] fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(15, 5)) ax[0].imshow(original_image) ax[0].set_title(f\"Original: {epoch:03d}\") ax[1].imshow(masked_image) ax[1].set_title(f\"Masked: {epoch:03d}\") ax[2].imshow(reconstructed_image) ax[2].set_title(f\"Resonstructed: {epoch:03d}\") plt.show() plt.close() Learning rate scheduler # Some code is taken from: # https://www.kaggle.com/ashusma/training-rfcx-tensorflow-tpu-effnet-b2. class WarmUpCosine(keras.optimizers.schedules.LearningRateSchedule): def __init__( self, learning_rate_base, total_steps, warmup_learning_rate, warmup_steps ): super(WarmUpCosine, self).__init__() self.learning_rate_base = learning_rate_base self.total_steps = total_steps self.warmup_learning_rate = warmup_learning_rate self.warmup_steps = warmup_steps self.pi = tf.constant(np.pi) def __call__(self, step): if self.total_steps < self.warmup_steps: raise ValueError(\"Total_steps must be larger or equal to warmup_steps.\") cos_annealed_lr = tf.cos( self.pi * (tf.cast(step, tf.float32) - self.warmup_steps) / float(self.total_steps - self.warmup_steps) ) learning_rate = 0.5 * self.learning_rate_base * (1 + cos_annealed_lr) if self.warmup_steps > 0: if self.learning_rate_base < self.warmup_learning_rate: raise ValueError( \"Learning_rate_base must be larger or equal to \" \"warmup_learning_rate.\" ) slope = ( self.learning_rate_base - self.warmup_learning_rate ) / self.warmup_steps warmup_rate = slope * tf.cast(step, tf.float32) + self.warmup_learning_rate learning_rate = tf.where( step < self.warmup_steps, warmup_rate, learning_rate ) return tf.where( step > self.total_steps, 0.0, learning_rate, name=\"learning_rate\" ) total_steps = int((len(x_train) / BATCH_SIZE) * EPOCHS) warmup_epoch_percentage = 0.15 warmup_steps = int(total_steps * warmup_epoch_percentage) scheduled_lrs = WarmUpCosine( learning_rate_base=LEARNING_RATE, total_steps=total_steps, warmup_learning_rate=0.0, warmup_steps=warmup_steps, ) lrs = [scheduled_lrs(step) for step in range(total_steps)] plt.plot(lrs) plt.xlabel(\"Step\", fontsize=14) plt.ylabel(\"LR\", fontsize=14) plt.show() # Assemble the callbacks. train_callbacks = [TrainMonitor(epoch_interval=5)] png Model compilation and training optimizer = tfa.optimizers.AdamW(learning_rate=scheduled_lrs, weight_decay=WEIGHT_DECAY) # Compile and pretrain the model. mae_model.compile( optimizer=optimizer, loss=keras.losses.MeanSquaredError(), metrics=[\"mae\"] ) history = mae_model.fit( train_ds, epochs=EPOCHS, validation_data=val_ds, callbacks=train_callbacks, ) # Measure its performance. loss, mae = mae_model.evaluate(test_ds) print(f\"Loss: {loss:.2f}\") print(f\"MAE: {mae:.2f}\") Epoch 1/100 157/157 [==============================] - ETA: 0s - loss: 0.0507 - mae: 0.1811 Idx chosen: 92 png 157/157 [==============================] - 19s 54ms/step - loss: 0.0507 - mae: 0.1811 - val_loss: 0.0417 - val_mae: 0.1630 Epoch 2/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0385 - mae: 0.1550 - val_loss: 0.0349 - val_mae: 0.1460 Epoch 3/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0336 - mae: 0.1420 - val_loss: 0.0311 - val_mae: 0.1352 Epoch 4/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0299 - mae: 0.1325 - val_loss: 0.0302 - val_mae: 0.1321 Epoch 5/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0269 - mae: 0.1246 - val_loss: 0.0256 - val_mae: 0.1207 Epoch 6/100 156/157 [============================>.] - ETA: 0s - loss: 0.0246 - mae: 0.1181 Idx chosen: 14 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0246 - mae: 0.1181 - val_loss: 0.0241 - val_mae: 0.1166 Epoch 7/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0232 - mae: 0.1142 - val_loss: 0.0237 - val_mae: 0.1152 Epoch 8/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0222 - mae: 0.1113 - val_loss: 0.0216 - val_mae: 0.1088 Epoch 9/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0214 - mae: 0.1086 - val_loss: 0.0217 - val_mae: 0.1096 Epoch 10/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0206 - mae: 0.1064 - val_loss: 0.0215 - val_mae: 0.1100 Epoch 11/100 157/157 [==============================] - ETA: 0s - loss: 0.0203 - mae: 0.1053 Idx chosen: 106 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0203 - mae: 0.1053 - val_loss: 0.0205 - val_mae: 0.1052 Epoch 12/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0200 - mae: 0.1043 - val_loss: 0.0196 - val_mae: 0.1028 Epoch 13/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0196 - mae: 0.1030 - val_loss: 0.0198 - val_mae: 0.1043 Epoch 14/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0193 - mae: 0.1019 - val_loss: 0.0192 - val_mae: 0.1004 Epoch 15/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0191 - mae: 0.1013 - val_loss: 0.0198 - val_mae: 0.1031 Epoch 16/100 157/157 [==============================] - ETA: 0s - loss: 0.0189 - mae: 0.1007 Idx chosen: 71 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0189 - mae: 0.1007 - val_loss: 0.0188 - val_mae: 0.1003 Epoch 17/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0185 - mae: 0.0992 - val_loss: 0.0187 - val_mae: 0.0993 Epoch 18/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0185 - mae: 0.0992 - val_loss: 0.0192 - val_mae: 0.1021 Epoch 19/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0182 - mae: 0.0984 - val_loss: 0.0181 - val_mae: 0.0967 Epoch 20/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0180 - mae: 0.0975 - val_loss: 0.0183 - val_mae: 0.0996 Epoch 21/100 156/157 [============================>.] - ETA: 0s - loss: 0.0180 - mae: 0.0975 Idx chosen: 188 png 157/157 [==============================] - 7s 47ms/step - loss: 0.0180 - mae: 0.0975 - val_loss: 0.0185 - val_mae: 0.0992 Epoch 22/100 157/157 [==============================] - 7s 45ms/step - loss: 0.0179 - mae: 0.0971 - val_loss: 0.0181 - val_mae: 0.0977 Epoch 23/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0178 - mae: 0.0966 - val_loss: 0.0179 - val_mae: 0.0962 Epoch 24/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0178 - mae: 0.0966 - val_loss: 0.0176 - val_mae: 0.0952 Epoch 25/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0176 - mae: 0.0960 - val_loss: 0.0182 - val_mae: 0.0984 Epoch 26/100 157/157 [==============================] - ETA: 0s - loss: 0.0175 - mae: 0.0958 Idx chosen: 20 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0175 - mae: 0.0958 - val_loss: 0.0176 - val_mae: 0.0958 Epoch 27/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0175 - mae: 0.0957 - val_loss: 0.0175 - val_mae: 0.0948 Epoch 28/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0175 - mae: 0.0956 - val_loss: 0.0173 - val_mae: 0.0947 Epoch 29/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0172 - mae: 0.0949 - val_loss: 0.0174 - val_mae: 0.0948 Epoch 30/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0172 - mae: 0.0948 - val_loss: 0.0174 - val_mae: 0.0944 Epoch 31/100 157/157 [==============================] - ETA: 0s - loss: 0.0172 - mae: 0.0945 Idx chosen: 102 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0172 - mae: 0.0945 - val_loss: 0.0169 - val_mae: 0.0932 Epoch 32/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0172 - mae: 0.0947 - val_loss: 0.0174 - val_mae: 0.0961 Epoch 33/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0171 - mae: 0.0945 - val_loss: 0.0171 - val_mae: 0.0937 Epoch 34/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0170 - mae: 0.0938 - val_loss: 0.0171 - val_mae: 0.0941 Epoch 35/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0170 - mae: 0.0940 - val_loss: 0.0171 - val_mae: 0.0948 Epoch 36/100 157/157 [==============================] - ETA: 0s - loss: 0.0168 - mae: 0.0933 Idx chosen: 121 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0168 - mae: 0.0933 - val_loss: 0.0170 - val_mae: 0.0935 Epoch 37/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0169 - mae: 0.0935 - val_loss: 0.0168 - val_mae: 0.0933 Epoch 38/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0168 - mae: 0.0933 - val_loss: 0.0170 - val_mae: 0.0935 Epoch 39/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0167 - mae: 0.0931 - val_loss: 0.0169 - val_mae: 0.0934 Epoch 40/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0167 - mae: 0.0930 - val_loss: 0.0169 - val_mae: 0.0934 Epoch 41/100 157/157 [==============================] - ETA: 0s - loss: 0.0167 - mae: 0.0929 Idx chosen: 210 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0167 - mae: 0.0929 - val_loss: 0.0169 - val_mae: 0.0930 Epoch 42/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0167 - mae: 0.0928 - val_loss: 0.0170 - val_mae: 0.0941 Epoch 43/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0166 - mae: 0.0925 - val_loss: 0.0169 - val_mae: 0.0931 Epoch 44/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0165 - mae: 0.0921 - val_loss: 0.0165 - val_mae: 0.0914 Epoch 45/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0165 - mae: 0.0922 - val_loss: 0.0165 - val_mae: 0.0915 Epoch 46/100 157/157 [==============================] - ETA: 0s - loss: 0.0165 - mae: 0.0922 Idx chosen: 214 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0165 - mae: 0.0922 - val_loss: 0.0166 - val_mae: 0.0914 Epoch 47/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0164 - mae: 0.0919 - val_loss: 0.0164 - val_mae: 0.0912 Epoch 48/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0163 - mae: 0.0914 - val_loss: 0.0166 - val_mae: 0.0923 Epoch 49/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0163 - mae: 0.0914 - val_loss: 0.0164 - val_mae: 0.0914 Epoch 50/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0162 - mae: 0.0912 - val_loss: 0.0164 - val_mae: 0.0916 Epoch 51/100 157/157 [==============================] - ETA: 0s - loss: 0.0162 - mae: 0.0913 Idx chosen: 74 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0162 - mae: 0.0913 - val_loss: 0.0165 - val_mae: 0.0919 Epoch 52/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0162 - mae: 0.0909 - val_loss: 0.0163 - val_mae: 0.0912 Epoch 53/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0161 - mae: 0.0908 - val_loss: 0.0161 - val_mae: 0.0903 Epoch 54/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0161 - mae: 0.0908 - val_loss: 0.0162 - val_mae: 0.0901 Epoch 55/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0161 - mae: 0.0907 - val_loss: 0.0162 - val_mae: 0.0909 Epoch 56/100 156/157 [============================>.] - ETA: 0s - loss: 0.0160 - mae: 0.0904 Idx chosen: 202 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0160 - mae: 0.0904 - val_loss: 0.0160 - val_mae: 0.0908 Epoch 57/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0159 - mae: 0.0902 - val_loss: 0.0160 - val_mae: 0.0899 Epoch 58/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0159 - mae: 0.0901 - val_loss: 0.0162 - val_mae: 0.0916 Epoch 59/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0159 - mae: 0.0898 - val_loss: 0.0160 - val_mae: 0.0903 Epoch 60/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0159 - mae: 0.0898 - val_loss: 0.0159 - val_mae: 0.0897 Epoch 61/100 157/157 [==============================] - ETA: 0s - loss: 0.0158 - mae: 0.0894 Idx chosen: 87 png 157/157 [==============================] - 7s 48ms/step - loss: 0.0158 - mae: 0.0894 - val_loss: 0.0160 - val_mae: 0.0895 Epoch 62/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0158 - mae: 0.0895 - val_loss: 0.0161 - val_mae: 0.0905 Epoch 63/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0157 - mae: 0.0891 - val_loss: 0.0158 - val_mae: 0.0894 Epoch 64/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0157 - mae: 0.0890 - val_loss: 0.0158 - val_mae: 0.0889 Epoch 65/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0157 - mae: 0.0890 - val_loss: 0.0159 - val_mae: 0.0893 Epoch 66/100 157/157 [==============================] - ETA: 0s - loss: 0.0156 - mae: 0.0888 Idx chosen: 116 png 157/157 [==============================] - 7s 47ms/step - loss: 0.0156 - mae: 0.0888 - val_loss: 0.0160 - val_mae: 0.0903 Epoch 67/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0156 - mae: 0.0886 - val_loss: 0.0156 - val_mae: 0.0881 Epoch 68/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0155 - mae: 0.0883 - val_loss: 0.0156 - val_mae: 0.0885 Epoch 69/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0154 - mae: 0.0881 - val_loss: 0.0155 - val_mae: 0.0878 Epoch 70/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0154 - mae: 0.0881 - val_loss: 0.0158 - val_mae: 0.0891 Epoch 71/100 156/157 [============================>.] - ETA: 0s - loss: 0.0154 - mae: 0.0879 Idx chosen: 99 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0154 - mae: 0.0879 - val_loss: 0.0155 - val_mae: 0.0884 Epoch 72/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0153 - mae: 0.0877 - val_loss: 0.0154 - val_mae: 0.0878 Epoch 73/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0153 - mae: 0.0876 - val_loss: 0.0155 - val_mae: 0.0879 Epoch 74/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0152 - mae: 0.0874 - val_loss: 0.0153 - val_mae: 0.0876 Epoch 75/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0152 - mae: 0.0872 - val_loss: 0.0153 - val_mae: 0.0872 Epoch 76/100 157/157 [==============================] - ETA: 0s - loss: 0.0151 - mae: 0.0870 Idx chosen: 103 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0151 - mae: 0.0870 - val_loss: 0.0153 - val_mae: 0.0873 Epoch 77/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0151 - mae: 0.0869 - val_loss: 0.0152 - val_mae: 0.0872 Epoch 78/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0151 - mae: 0.0867 - val_loss: 0.0152 - val_mae: 0.0869 Epoch 79/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0151 - mae: 0.0867 - val_loss: 0.0151 - val_mae: 0.0863 Epoch 80/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0150 - mae: 0.0865 - val_loss: 0.0150 - val_mae: 0.0860 Epoch 81/100 157/157 [==============================] - ETA: 0s - loss: 0.0150 - mae: 0.0865 Idx chosen: 151 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0150 - mae: 0.0865 - val_loss: 0.0151 - val_mae: 0.0862 Epoch 82/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0149 - mae: 0.0861 - val_loss: 0.0151 - val_mae: 0.0859 Epoch 83/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0149 - mae: 0.0861 - val_loss: 0.0149 - val_mae: 0.0857 Epoch 84/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0149 - mae: 0.0860 - val_loss: 0.0151 - val_mae: 0.0865 Epoch 85/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0148 - mae: 0.0858 - val_loss: 0.0150 - val_mae: 0.0856 Epoch 86/100 157/157 [==============================] - ETA: 0s - loss: 0.0148 - mae: 0.0856 Idx chosen: 130 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0148 - mae: 0.0856 - val_loss: 0.0149 - val_mae: 0.0855 Epoch 87/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0148 - mae: 0.0855 - val_loss: 0.0148 - val_mae: 0.0851 Epoch 88/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0148 - mae: 0.0856 - val_loss: 0.0149 - val_mae: 0.0855 Epoch 89/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0147 - mae: 0.0853 - val_loss: 0.0148 - val_mae: 0.0852 Epoch 90/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0147 - mae: 0.0853 - val_loss: 0.0148 - val_mae: 0.0850 Epoch 91/100 157/157 [==============================] - ETA: 0s - loss: 0.0147 - mae: 0.0852 Idx chosen: 149 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0147 - mae: 0.0852 - val_loss: 0.0148 - val_mae: 0.0851 Epoch 92/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0146 - mae: 0.0851 - val_loss: 0.0147 - val_mae: 0.0849 Epoch 93/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0147 - mae: 0.0853 - val_loss: 0.0147 - val_mae: 0.0849 Epoch 94/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0147 - mae: 0.0852 - val_loss: 0.0148 - val_mae: 0.0850 Epoch 95/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0147 - mae: 0.0852 - val_loss: 0.0148 - val_mae: 0.0853 Epoch 96/100 157/157 [==============================] - ETA: 0s - loss: 0.0147 - mae: 0.0853 Idx chosen: 52 png 157/157 [==============================] - 7s 46ms/step - loss: 0.0147 - mae: 0.0853 - val_loss: 0.0148 - val_mae: 0.0853 Epoch 97/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0148 - mae: 0.0856 - val_loss: 0.0149 - val_mae: 0.0855 Epoch 98/100 157/157 [==============================] - 7s 43ms/step - loss: 0.0148 - mae: 0.0857 - val_loss: 0.0149 - val_mae: 0.0858 Epoch 99/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0149 - mae: 0.0863 - val_loss: 0.0150 - val_mae: 0.0865 Epoch 100/100 157/157 [==============================] - 7s 44ms/step - loss: 0.0150 - mae: 0.0873 - val_loss: 0.0153 - val_mae: 0.0881 40/40 [==============================] - 1s 15ms/step - loss: 0.0154 - mae: 0.0882 Loss: 0.02 MAE: 0.09 Evaluation with linear probing Extract the encoder model along with other layers # Extract the augmentation layers. train_augmentation_model = mae_model.train_augmentation_model test_augmentation_model = mae_model.test_augmentation_model # Extract the patchers. patch_layer = mae_model.patch_layer patch_encoder = mae_model.patch_encoder patch_encoder.downstream = True # Swtich the downstream flag to True. # Extract the encoder. encoder = mae_model.encoder # Pack as a model. downstream_model = keras.Sequential( [ layers.Input((IMAGE_SIZE, IMAGE_SIZE, 3)), patch_layer, patch_encoder, encoder, layers.BatchNormalization(), # Refer to A.1 (Linear probing). layers.GlobalAveragePooling1D(), layers.Dense(NUM_CLASSES, activation=\"softmax\"), ], name=\"linear_probe_model\", ) # Only the final classification layer of the `downstream_model` should be trainable. for layer in downstream_model.layers[:-1]: layer.trainable = False downstream_model.summary() Model: \"linear_probe_model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= patches_1 (Patches) (None, 64, 108) 0 patch_encoder_1 (PatchEncod (None, 64, 128) 22252 er) mae_encoder (Functional) (None, None, 128) 1981696 batch_normalization (BatchN (None, 64, 128) 512 ormalization) global_average_pooling1d (G (None, 128) 0 lobalAveragePooling1D) dense_19 (Dense) (None, 10) 1290 ================================================================= Total params: 2,005,750 Trainable params: 1,290 Non-trainable params: 2,004,460 _________________________________________________________________ We are using average pooling to extract learned representations from the MAE encoder. Another approach would be to use a learnable dummy token inside the encoder during pretraining (resembling the [CLS] token). Then we can extract representations from that token during the downstream tasks. Prepare datasets for linear probing def prepare_data(images, labels, is_train=True): if is_train: augmentation_model = train_augmentation_model else: augmentation_model = test_augmentation_model dataset = tf.data.Dataset.from_tensor_slices((images, labels)) if is_train: dataset = dataset.shuffle(BUFFER_SIZE) dataset = dataset.batch(BATCH_SIZE).map( lambda x, y: (augmentation_model(x), y), num_parallel_calls=AUTO ) return dataset.prefetch(AUTO) train_ds = prepare_data(x_train, y_train) val_ds = prepare_data(x_train, y_train, is_train=False) test_ds = prepare_data(x_test, y_test, is_train=False) Perform linear probing linear_probe_epochs = 50 linear_prob_lr = 0.1 warm_epoch_percentage = 0.1 steps = int((len(x_train) // BATCH_SIZE) * linear_probe_epochs) warmup_steps = int(steps * warm_epoch_percentage) scheduled_lrs = WarmUpCosine( learning_rate_base=linear_prob_lr, total_steps=steps, warmup_learning_rate=0.0, warmup_steps=warmup_steps, ) optimizer = keras.optimizers.SGD(learning_rate=scheduled_lrs, momentum=0.9) downstream_model.compile( optimizer=optimizer, loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"] ) downstream_model.fit(train_ds, validation_data=val_ds, epochs=linear_probe_epochs) loss, accuracy = downstream_model.evaluate(test_ds) accuracy = round(accuracy * 100, 2) print(f\"Accuracy on the test set: {accuracy}%.\") Epoch 1/50 157/157 [==============================] - 11s 43ms/step - loss: 2.2131 - accuracy: 0.1838 - val_loss: 2.0249 - val_accuracy: 0.2986 Epoch 2/50 157/157 [==============================] - 6s 36ms/step - loss: 1.9065 - accuracy: 0.3498 - val_loss: 1.7813 - val_accuracy: 0.3913 Epoch 3/50 157/157 [==============================] - 6s 36ms/step - loss: 1.7443 - accuracy: 0.3995 - val_loss: 1.6705 - val_accuracy: 0.4195 Epoch 4/50 157/157 [==============================] - 6s 36ms/step - loss: 1.6645 - accuracy: 0.4201 - val_loss: 1.6107 - val_accuracy: 0.4344 Epoch 5/50 157/157 [==============================] - 6s 36ms/step - loss: 1.6169 - accuracy: 0.4320 - val_loss: 1.5747 - val_accuracy: 0.4435 Epoch 6/50 157/157 [==============================] - 6s 36ms/step - loss: 1.5843 - accuracy: 0.4364 - val_loss: 1.5476 - val_accuracy: 0.4496 Epoch 7/50 157/157 [==============================] - 6s 36ms/step - loss: 1.5634 - accuracy: 0.4418 - val_loss: 1.5294 - val_accuracy: 0.4540 Epoch 8/50 157/157 [==============================] - 6s 36ms/step - loss: 1.5462 - accuracy: 0.4452 - val_loss: 1.5158 - val_accuracy: 0.4575 Epoch 9/50 157/157 [==============================] - 6s 36ms/step - loss: 1.5365 - accuracy: 0.4468 - val_loss: 1.5068 - val_accuracy: 0.4602 Epoch 10/50 157/157 [==============================] - 6s 36ms/step - loss: 1.5237 - accuracy: 0.4541 - val_loss: 1.4971 - val_accuracy: 0.4616 Epoch 11/50 157/157 [==============================] - 6s 36ms/step - loss: 1.5171 - accuracy: 0.4539 - val_loss: 1.4902 - val_accuracy: 0.4620 Epoch 12/50 157/157 [==============================] - 6s 37ms/step - loss: 1.5127 - accuracy: 0.4552 - val_loss: 1.4850 - val_accuracy: 0.4640 Epoch 13/50 157/157 [==============================] - 6s 36ms/step - loss: 1.5027 - accuracy: 0.4590 - val_loss: 1.4796 - val_accuracy: 0.4669 Epoch 14/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4985 - accuracy: 0.4587 - val_loss: 1.4747 - val_accuracy: 0.4673 Epoch 15/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4975 - accuracy: 0.4588 - val_loss: 1.4694 - val_accuracy: 0.4694 Epoch 16/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4933 - accuracy: 0.4596 - val_loss: 1.4661 - val_accuracy: 0.4698 Epoch 17/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4889 - accuracy: 0.4608 - val_loss: 1.4628 - val_accuracy: 0.4721 Epoch 18/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4869 - accuracy: 0.4659 - val_loss: 1.4623 - val_accuracy: 0.4721 Epoch 19/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4826 - accuracy: 0.4639 - val_loss: 1.4585 - val_accuracy: 0.4716 Epoch 20/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4813 - accuracy: 0.4653 - val_loss: 1.4559 - val_accuracy: 0.4743 Epoch 21/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4824 - accuracy: 0.4644 - val_loss: 1.4542 - val_accuracy: 0.4746 Epoch 22/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4768 - accuracy: 0.4667 - val_loss: 1.4526 - val_accuracy: 0.4757 Epoch 23/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4775 - accuracy: 0.4644 - val_loss: 1.4507 - val_accuracy: 0.4751 Epoch 24/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4750 - accuracy: 0.4670 - val_loss: 1.4481 - val_accuracy: 0.4756 Epoch 25/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4726 - accuracy: 0.4663 - val_loss: 1.4467 - val_accuracy: 0.4767 Epoch 26/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4706 - accuracy: 0.4681 - val_loss: 1.4450 - val_accuracy: 0.4781 Epoch 27/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4660 - accuracy: 0.4706 - val_loss: 1.4456 - val_accuracy: 0.4766 Epoch 28/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4664 - accuracy: 0.4707 - val_loss: 1.4443 - val_accuracy: 0.4776 Epoch 29/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4678 - accuracy: 0.4674 - val_loss: 1.4411 - val_accuracy: 0.4802 Epoch 30/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4654 - accuracy: 0.4704 - val_loss: 1.4411 - val_accuracy: 0.4801 Epoch 31/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4655 - accuracy: 0.4702 - val_loss: 1.4402 - val_accuracy: 0.4787 Epoch 32/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4620 - accuracy: 0.4735 - val_loss: 1.4402 - val_accuracy: 0.4781 Epoch 33/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4668 - accuracy: 0.4699 - val_loss: 1.4397 - val_accuracy: 0.4783 Epoch 34/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4619 - accuracy: 0.4724 - val_loss: 1.4382 - val_accuracy: 0.4793 Epoch 35/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4652 - accuracy: 0.4697 - val_loss: 1.4374 - val_accuracy: 0.4800 Epoch 36/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4618 - accuracy: 0.4707 - val_loss: 1.4372 - val_accuracy: 0.4794 Epoch 37/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4606 - accuracy: 0.4710 - val_loss: 1.4369 - val_accuracy: 0.4793 Epoch 38/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4613 - accuracy: 0.4706 - val_loss: 1.4363 - val_accuracy: 0.4806 Epoch 39/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4631 - accuracy: 0.4713 - val_loss: 1.4361 - val_accuracy: 0.4804 Epoch 40/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4620 - accuracy: 0.4695 - val_loss: 1.4357 - val_accuracy: 0.4802 Epoch 41/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4639 - accuracy: 0.4706 - val_loss: 1.4355 - val_accuracy: 0.4801 Epoch 42/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4588 - accuracy: 0.4735 - val_loss: 1.4352 - val_accuracy: 0.4802 Epoch 43/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4573 - accuracy: 0.4734 - val_loss: 1.4352 - val_accuracy: 0.4794 Epoch 44/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4597 - accuracy: 0.4723 - val_loss: 1.4350 - val_accuracy: 0.4796 Epoch 45/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4572 - accuracy: 0.4741 - val_loss: 1.4349 - val_accuracy: 0.4799 Epoch 46/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4561 - accuracy: 0.4756 - val_loss: 1.4348 - val_accuracy: 0.4801 Epoch 47/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4593 - accuracy: 0.4730 - val_loss: 1.4348 - val_accuracy: 0.4801 Epoch 48/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4613 - accuracy: 0.4733 - val_loss: 1.4348 - val_accuracy: 0.4802 Epoch 49/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4591 - accuracy: 0.4710 - val_loss: 1.4348 - val_accuracy: 0.4803 Epoch 50/50 157/157 [==============================] - 6s 36ms/step - loss: 1.4566 - accuracy: 0.4766 - val_loss: 1.4348 - val_accuracy: 0.4803 40/40 [==============================] - 1s 17ms/step - loss: 1.4375 - accuracy: 0.4790 Accuracy on the test set: 47.9%. We believe that with a more sophisticated hyperparameter tuning process and a longer pretraining it is possible to improve this performance further. For comparison, we took the encoder architecture and trained it from scratch in a fully supervised manner. This gave us ~76% test top-1 accuracy. The authors of MAE demonstrates strong performance on the ImageNet-1k dataset as well as other downstream tasks like object detection and semantic segmentation. Final notes We refer the interested readers to other examples on self-supervised learning present on keras.io: SimCLR NNCLR SimSiam This idea of using BERT flavored pretraining in computer vision was also explored in Selfie, but it could not demonstrate strong results. Another concurrent work that explores the idea of masked image modeling is SimMIM. Finally, as a fun fact, we, the authors of this example also explored the idea of \"reconstruction as a pretext task\" in 2020 but we could not prevent the network from representation collapse, and hence we did not get strong downstream performance. We would like to thank Xinlei Chen (one of the authors of MAE) for helpful discussions. We are grateful to JarvisLabs and Google Developers Experts program for helping with GPU credits Example of using similarity metric learning on CIFAR-10 images. Overview This example is based on the \"Metric learning for image similarity search\" example. We aim to use the same data set but implement the model using TensorFlow Similarity. Metric learning aims to train models that can embed inputs into a high-dimensional space such that \"similar\" inputs are pulled closer to each other and \"dissimilar\" inputs are pushed farther apart. Once trained, these models can produce embeddings for downstream systems where such similarity is useful, for instance as a ranking signal for search or as a form of pretrained embedding model for another supervised problem. For a more detailed overview of metric learning, see: What is metric learning? \"Using crossentropy for metric learning\" tutorial Setup This tutorial will use the TensorFlow Similarity library to learn and evaluate the similarity embedding. TensorFlow Similarity provides components that: Make training contrastive models simple and fast. Make it easier to ensure that batches contain pairs of examples. Enable the evaluation of the quality of the embedding. import random from matplotlib import pyplot as plt from mpl_toolkits import axes_grid1 import numpy as np import tensorflow as tf from tensorflow import keras import tensorflow_similarity as tfsim tfsim.utils.tf_cap_memory() print(\"TensorFlow:\", tf.__version__) print(\"TensorFlow Similarity:\", tfsim.__version__) TensorFlow: 2.6.0 TensorFlow Similarity: 0.14 Dataset samplers We will be using the CIFAR-10 dataset for this tutorial. For a similarity model to learn efficiently, each batch must contains at least 2 examples of each class. To make this easy, tf_similarity offers Sampler objects that enable you to set both the number of classes and the minimum number of examples of each class per batch. The train and validation datasets will be created using the TFDatasetMultiShotMemorySampler object. This creates a sampler that loads datasets from TensorFlow Datasets and yields batches containing a target number of classes and a target number of examples per class. Additionally, we can restrict the sampler to only yield the subset of classes defined in class_list, enabling us to train on a subset of the classes and then test how the embedding generalizes to the unseen classes. This can be useful when working on few-shot learning problems. The following cell creates a train_ds sample that: Loads the CIFAR-10 dataset from TFDS and then takes the examples_per_class_per_batch. Ensures the sampler restricts the classes to those defined in class_list. Ensures each batch contains 10 different classes with 8 examples each. We also create a validation dataset in the same way, but we limit the total number of examples per class to 100 and the examples per class per batch is set to the default of 2. # This determines the number of classes used during training. # Here we are using all the classes. num_known_classes = 10 class_list = random.sample(population=range(10), k=num_known_classes) classes_per_batch = 10 # Passing multiple examples per class per batch ensures that each example has # multiple positive pairs. This can be useful when performing triplet mining or # when using losses like `MultiSimilarityLoss` or `CircleLoss` as these can # take a weighted mix of all the positive pairs. In general, more examples per # class will lead to more information for the positive pairs, while more classes # per batch will provide more varied information in the negative pairs. However, # the losses compute the pairwise distance between the examples in a batch so # the upper limit of the batch size is restricted by the memory. examples_per_class_per_batch = 8 print( \"Batch size is: \" f\"{min(classes_per_batch, num_known_classes) * examples_per_class_per_batch}\" ) print(\" Create Training Data \".center(34, \"#\")) train_ds = tfsim.samplers.TFDatasetMultiShotMemorySampler( \"cifar10\", classes_per_batch=min(classes_per_batch, num_known_classes), splits=\"train\", steps_per_epoch=4000, examples_per_class_per_batch=examples_per_class_per_batch, class_list=class_list, ) print(\"\n\" + \" Create Validation Data \".center(34, \"#\")) val_ds = tfsim.samplers.TFDatasetMultiShotMemorySampler( \"cifar10\", classes_per_batch=classes_per_batch, splits=\"test\", total_examples_per_class=100, ) Batch size is: 80 ###### Create Training Data ###### 2021-10-07 22:48:06.609114: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. converting train: 0%| | 0/50000 [00:00ap\", anchor_embeddings, positive_embeddings ) # Since we intend to use these as logits we scale them by a temperature. # This value would normally be chosen as a hyper parameter. temperature = 0.2 similarities /= temperature # We use these similarities as logits for a softmax. The labels for # this call are just the sequence [0, 1, 2, ..., num_classes] since we # want the main diagonal values, which correspond to the anchor/positive # pairs, to be high. This loss will move embeddings for the # anchor/positive pairs together and move all other pairs apart. sparse_labels = tf.range(num_classes) loss = self.compiled_loss(sparse_labels, similarities) # Calculate gradients and apply via optimizer. gradients = tape.gradient(loss, self.trainable_variables) self.optimizer.apply_gradients(zip(gradients, self.trainable_variables)) # Update and return metrics (specifically the one for the loss value). self.compiled_metrics.update_state(sparse_labels, similarities) return {m.name: m.result() for m in self.metrics} Next we describe the architecture that maps from an image to an embedding. This model simply consists of a sequence of 2d convolutions followed by global pooling with a final linear projection to an embedding space. As is common in metric learning we normalise the embeddings so that we can use simple dot products to measure similarity. For simplicity this model is intentionally small. inputs = layers.Input(shape=(height_width, height_width, 3)) x = layers.Conv2D(filters=32, kernel_size=3, strides=2, activation=\"relu\")(inputs) x = layers.Conv2D(filters=64, kernel_size=3, strides=2, activation=\"relu\")(x) x = layers.Conv2D(filters=128, kernel_size=3, strides=2, activation=\"relu\")(x) x = layers.GlobalAveragePooling2D()(x) embeddings = layers.Dense(units=8, activation=None)(x) embeddings = tf.nn.l2_normalize(embeddings, axis=-1) model = EmbeddingModel(inputs, embeddings) Finally we run the training. On a Google Colab GPU instance this takes about a minute. model.compile( optimizer=keras.optimizers.Adam(learning_rate=1e-3), loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), ) history = model.fit(AnchorPositivePairs(num_batchs=1000), epochs=20) plt.plot(history.history[\"loss\"]) plt.show() Epoch 1/20 1000/1000 [==============================] - 4s 4ms/step - loss: 2.2475 Epoch 2/20 1000/1000 [==============================] - 5s 5ms/step - loss: 2.1246 Epoch 3/20 1000/1000 [==============================] - 7s 7ms/step - loss: 2.0519 Epoch 4/20 1000/1000 [==============================] - 8s 8ms/step - loss: 2.0011 Epoch 5/20 1000/1000 [==============================] - 9s 9ms/step - loss: 1.9601 Epoch 6/20 1000/1000 [==============================] - 9s 9ms/step - loss: 1.9214 Epoch 7/20 1000/1000 [==============================] - 9s 9ms/step - loss: 1.9094 Epoch 8/20 1000/1000 [==============================] - 10s 10ms/step - loss: 1.8669 Epoch 9/20 1000/1000 [==============================] - 10s 10ms/step - loss: 1.8462 Epoch 10/20 1000/1000 [==============================] - 10s 10ms/step - loss: 1.8095 Epoch 11/20 1000/1000 [==============================] - 10s 10ms/step - loss: 1.7854 Epoch 12/20 1000/1000 [==============================] - 11s 11ms/step - loss: 1.7595 Epoch 13/20 1000/1000 [==============================] - 11s 11ms/step - loss: 1.7538 Epoch 14/20 1000/1000 [==============================] - 11s 11ms/step - loss: 1.7198 Epoch 15/20 906/1000 [==========================>...] - ETA: 1s - loss: 1.7017 Testing We can review the quality of this model by applying it to the test set and considering near neighbours in the embedding space. First we embed the test set and calculate all near neighbours. Recall that since the embeddings are unit length we can calculate cosine similarity via dot products. near_neighbours_per_example = 10 embeddings = model.predict(x_test) gram_matrix = np.einsum(\"ae,be->ab\", embeddings, embeddings) near_neighbours = np.argsort(gram_matrix.T)[:, -(near_neighbours_per_example + 1) :] As a visual check of these embeddings we can build a collage of the near neighbours for 5 random examples. The first column of the image below is a randomly selected image, the following 10 columns show the nearest neighbours in order of similarity. num_collage_examples = 5 examples = np.empty( ( num_collage_examples, near_neighbours_per_example + 1, height_width, height_width, 3, ), dtype=np.float32, ) for row_idx in range(num_collage_examples): examples[row_idx, 0] = x_test[row_idx] anchor_near_neighbours = reversed(near_neighbours[row_idx][:-1]) for col_idx, nn_idx in enumerate(anchor_near_neighbours): examples[row_idx, col_idx + 1] = x_test[nn_idx] show_collage(examples) png We can also get a quantified view of the performance by considering the correctness of near neighbours in terms of a confusion matrix. Let us sample 10 examples from each of the 10 classes and consider their near neighbours as a form of prediction; that is, does the example and its near neighbours share the same class? We observe that each animal class does generally well, and is confused the most with the other animal classes. The vehicle classes follow the same pattern. confusion_matrix = np.zeros((num_classes, num_classes)) # For each class. for class_idx in range(num_classes): # Consider 10 examples. example_idxs = class_idx_to_test_idxs[class_idx][:10] for y_test_idx in example_idxs: # And count the classes of its near neighbours. for nn_idx in near_neighbours[y_test_idx][:-1]: nn_class_idx = y_test[nn_idx] confusion_matrix[class_idx, nn_class_idx] += 1 # Display a confusion matrix. labels = [ \"Airplane\", \"Automobile\", \"Bird\", \"Cat\", \"Deer\", \"Dog\", \"Frog\", \"Horse\", \"Ship\", \"Truck\", ] disp = ConfusionMatrixDisplay(confusion_matrix=confusion_matrix, display_labels=labels) disp.plot(include_values=True, cmap=\"viridis\", ax=None, xticks_rotation=\"vertical\") plt.show() png Data augmentation using the mixup technique for image classification. Introduction mixup is a domain-agnostic data augmentation technique proposed in mixup: Beyond Empirical Risk Minimization by Zhang et al. It's implemented with the following formulas: (Note that the lambda values are values with the [0, 1] range and are sampled from the Beta distribution.) The technique is quite systematically named - we are literally mixing up the features and their corresponding labels. Implementation-wise it's simple. Neural networks are prone to memorizing corrupt labels. mixup relaxes this by combining different features with one another (same happens for the labels too) so that a network does not get overconfident about the relationship between the features and their labels. mixup is specifically useful when we are not sure about selecting a set of augmentation transforms for a given dataset, medical imaging datasets, for example. mixup can be extended to a variety of data modalities such as computer vision, naturallanguage processing, speech, and so on. This example requires TensorFlow 2.4 or higher. Setup import numpy as np import tensorflow as tf import matplotlib.pyplot as plt from tensorflow.keras import layers Prepare the dataset In this example, we will be using the FashionMNIST dataset. But this same recipe can be used for other classification datasets as well. (x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data() x_train = x_train.astype(\"float32\") / 255.0 x_train = np.reshape(x_train, (-1, 28, 28, 1)) y_train = tf.one_hot(y_train, 10) x_test = x_test.astype(\"float32\") / 255.0 x_test = np.reshape(x_test, (-1, 28, 28, 1)) y_test = tf.one_hot(y_test, 10) Define hyperparameters AUTO = tf.data.AUTOTUNE BATCH_SIZE = 64 EPOCHS = 10 Convert the data into TensorFlow Dataset objects # Put aside a few samples to create our validation set val_samples = 2000 x_val, y_val = x_train[:val_samples], y_train[:val_samples] new_x_train, new_y_train = x_train[val_samples:], y_train[val_samples:] train_ds_one = ( tf.data.Dataset.from_tensor_slices((new_x_train, new_y_train)) .shuffle(BATCH_SIZE * 100) .batch(BATCH_SIZE) ) train_ds_two = ( tf.data.Dataset.from_tensor_slices((new_x_train, new_y_train)) .shuffle(BATCH_SIZE * 100) .batch(BATCH_SIZE) ) # Because we will be mixing up the images and their corresponding labels, we will be # combining two shuffled datasets from the same training data. train_ds = tf.data.Dataset.zip((train_ds_one, train_ds_two)) val_ds = tf.data.Dataset.from_tensor_slices((x_val, y_val)).batch(BATCH_SIZE) test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(BATCH_SIZE) Define the mixup technique function To perform the mixup routine, we create new virtual datasets using the training data from the same dataset, and apply a lambda value within the [0, 1] range sampled from a Beta distribution — such that, for example, new_x = lambda * x1 + (1 - lambda) * x2 (where x1 and x2 are images) and the same equation is applied to the labels as well. def sample_beta_distribution(size, concentration_0=0.2, concentration_1=0.2): gamma_1_sample = tf.random.gamma(shape=[size], alpha=concentration_1) gamma_2_sample = tf.random.gamma(shape=[size], alpha=concentration_0) return gamma_1_sample / (gamma_1_sample + gamma_2_sample) def mix_up(ds_one, ds_two, alpha=0.2): # Unpack two datasets images_one, labels_one = ds_one images_two, labels_two = ds_two batch_size = tf.shape(images_one)[0] # Sample lambda and reshape it to do the mixup l = sample_beta_distribution(batch_size, alpha, alpha) x_l = tf.reshape(l, (batch_size, 1, 1, 1)) y_l = tf.reshape(l, (batch_size, 1)) # Perform mixup on both images and labels by combining a pair of images/labels # (one from each dataset) into one image/label images = images_one * x_l + images_two * (1 - x_l) labels = labels_one * y_l + labels_two * (1 - y_l) return (images, labels) Note that here , we are combining two images to create a single one. Theoretically, we can combine as many we want but that comes at an increased computation cost. In certain cases, it may not help improve the performance as well. Visualize the new augmented dataset # First create the new dataset using our `mix_up` utility train_ds_mu = train_ds.map( lambda ds_one, ds_two: mix_up(ds_one, ds_two, alpha=0.2), num_parallel_calls=AUTO ) # Let's preview 9 samples from the dataset sample_images, sample_labels = next(iter(train_ds_mu)) plt.figure(figsize=(10, 10)) for i, (image, label) in enumerate(zip(sample_images[:9], sample_labels[:9])): ax = plt.subplot(3, 3, i + 1) plt.imshow(image.numpy().squeeze()) print(label.numpy().tolist()) plt.axis(\"off\") [0.01706075668334961, 0.0, 0.0, 0.9829392433166504, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] [0.0, 0.5761554837226868, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.42384451627731323, 0.0] [0.0, 0.0, 0.9999957084655762, 0.0, 4.291534423828125e-06, 0.0, 0.0, 0.0, 0.0, 0.0] [0.0, 0.0, 0.03438800573348999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.96561199426651, 0.0] [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0] [0.0, 0.0, 0.9808260202407837, 0.0, 0.0, 0.0, 0.01917397230863571, 0.0, 0.0, 0.0] [0.0, 0.9999748468399048, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.5153160095214844e-05] [0.0, 0.0, 0.0, 0.0002035107754636556, 0.0, 0.9997965097427368, 0.0, 0.0, 0.0, 0.0] [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2410212755203247, 0.0, 0.0, 0.7589787244796753] png Model building def get_training_model(): model = tf.keras.Sequential( [ layers.Conv2D(16, (5, 5), activation=\"relu\", input_shape=(28, 28, 1)), layers.MaxPooling2D(pool_size=(2, 2)), layers.Conv2D(32, (5, 5), activation=\"relu\"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Dropout(0.2), layers.GlobalAvgPool2D(), layers.Dense(128, activation=\"relu\"), layers.Dense(10, activation=\"softmax\"), ] ) return model For the sake of reproducibility, we serialize the initial random weights of our shallow network. initial_model = get_training_model() initial_model.save_weights(\"initial_weights.h5\") 1. Train the model with the mixed up dataset model = get_training_model() model.load_weights(\"initial_weights.h5\") model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) model.fit(train_ds_mu, validation_data=val_ds, epochs=EPOCHS) _, test_acc = model.evaluate(test_ds) print(\"Test accuracy: {:.2f}%\".format(test_acc * 100)) Epoch 1/10 907/907 [==============================] - 38s 41ms/step - loss: 1.4440 - accuracy: 0.5173 - val_loss: 0.7120 - val_accuracy: 0.7405 Epoch 2/10 907/907 [==============================] - 38s 42ms/step - loss: 0.9869 - accuracy: 0.7074 - val_loss: 0.5996 - val_accuracy: 0.7780 Epoch 3/10 907/907 [==============================] - 38s 42ms/step - loss: 0.9096 - accuracy: 0.7451 - val_loss: 0.5197 - val_accuracy: 0.8285 Epoch 4/10 907/907 [==============================] - 38s 42ms/step - loss: 0.8485 - accuracy: 0.7741 - val_loss: 0.4830 - val_accuracy: 0.8380 Epoch 5/10 907/907 [==============================] - 38s 42ms/step - loss: 0.8032 - accuracy: 0.7916 - val_loss: 0.4543 - val_accuracy: 0.8445 Epoch 6/10 907/907 [==============================] - 38s 42ms/step - loss: 0.7675 - accuracy: 0.8032 - val_loss: 0.4398 - val_accuracy: 0.8470 Epoch 7/10 907/907 [==============================] - 38s 42ms/step - loss: 0.7474 - accuracy: 0.8098 - val_loss: 0.4262 - val_accuracy: 0.8495 Epoch 8/10 907/907 [==============================] - 38s 42ms/step - loss: 0.7337 - accuracy: 0.8145 - val_loss: 0.3950 - val_accuracy: 0.8650 Epoch 9/10 907/907 [==============================] - 38s 42ms/step - loss: 0.7154 - accuracy: 0.8218 - val_loss: 0.3822 - val_accuracy: 0.8725 Epoch 10/10 907/907 [==============================] - 38s 42ms/step - loss: 0.7095 - accuracy: 0.8224 - val_loss: 0.3563 - val_accuracy: 0.8720 157/157 [==============================] - 2s 14ms/step - loss: 0.3821 - accuracy: 0.8726 Test accuracy: 87.26% 2. Train the model without the mixed up dataset model = get_training_model() model.load_weights(\"initial_weights.h5\") model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) # Notice that we are NOT using the mixed up dataset here model.fit(train_ds_one, validation_data=val_ds, epochs=EPOCHS) _, test_acc = model.evaluate(test_ds) print(\"Test accuracy: {:.2f}%\".format(test_acc * 100)) Epoch 1/10 907/907 [==============================] - 37s 40ms/step - loss: 1.2037 - accuracy: 0.5553 - val_loss: 0.6732 - val_accuracy: 0.7565 Epoch 2/10 907/907 [==============================] - 37s 40ms/step - loss: 0.6724 - accuracy: 0.7462 - val_loss: 0.5715 - val_accuracy: 0.7940 Epoch 3/10 907/907 [==============================] - 37s 40ms/step - loss: 0.5828 - accuracy: 0.7897 - val_loss: 0.5042 - val_accuracy: 0.8210 Epoch 4/10 907/907 [==============================] - 37s 40ms/step - loss: 0.5203 - accuracy: 0.8115 - val_loss: 0.4587 - val_accuracy: 0.8405 Epoch 5/10 907/907 [==============================] - 36s 40ms/step - loss: 0.4802 - accuracy: 0.8255 - val_loss: 0.4602 - val_accuracy: 0.8340 Epoch 6/10 907/907 [==============================] - 36s 40ms/step - loss: 0.4566 - accuracy: 0.8351 - val_loss: 0.3985 - val_accuracy: 0.8700 Epoch 7/10 907/907 [==============================] - 37s 40ms/step - loss: 0.4273 - accuracy: 0.8457 - val_loss: 0.3764 - val_accuracy: 0.8685 Epoch 8/10 907/907 [==============================] - 36s 40ms/step - loss: 0.4133 - accuracy: 0.8481 - val_loss: 0.3704 - val_accuracy: 0.8735 Epoch 9/10 907/907 [==============================] - 36s 40ms/step - loss: 0.3951 - accuracy: 0.8543 - val_loss: 0.3715 - val_accuracy: 0.8680 Epoch 10/10 907/907 [==============================] - 36s 40ms/step - loss: 0.3850 - accuracy: 0.8586 - val_loss: 0.3458 - val_accuracy: 0.8735 157/157 [==============================] - 2s 13ms/step - loss: 0.3817 - accuracy: 0.8636 Test accuracy: 86.36% Readers are encouraged to try out mixup on different datasets from different domains and experiment with the lambda parameter. You are strongly advised to check out the original paper as well - the authors present several ablation studies on mixup showing how it can improve generalization, as well as show their results of combining more than two images to create a single one. Notes With mixup, you can create synthetic examples — especially when you lack a large dataset - without incurring high computational costs. Label smoothing and mixup usually do not work well together because label smoothing already modifies the hard labels by some factor. mixup does not work well when you are using Supervised Contrastive Learning (SCL) since SCL expects the true labels during its pre-training phase. A few other benefits of mixup include (as described in the paper) robustness to adversarial examples and stabilized GAN (Generative Adversarial Networks) training. There are a number of data augmentation techniques that extend mixup such as CutMix and AugMix. MobileViT for image classification with combined benefits of convolutions and Transformers. Introduction In this example, we implement the MobileViT architecture (Mehta et al.), which combines the benefits of Transformers (Vaswani et al.) and convolutions. With Transformers, we can capture long-range dependencies that result in global representations. With convolutions, we can capture spatial relationships that model locality. Besides combining the properties of Transformers and convolutions, the authors introduce MobileViT as a general-purpose mobile-friendly backbone for different image recognition tasks. Their findings suggest that, performance-wise, MobileViT is better than other models with the same or higher complexity (MobileNetV3, for example), while being efficient on mobile devices. Imports import tensorflow as tf from keras.applications import imagenet_utils from tensorflow.keras import layers from tensorflow import keras import tensorflow_datasets as tfds import tensorflow_addons as tfa tfds.disable_progress_bar() Hyperparameters # Values are from table 4. patch_size = 4 # 2x2, for the Transformer blocks. image_size = 256 expansion_factor = 2 # expansion factor for the MobileNetV2 blocks. MobileViT utilities The MobileViT architecture is comprised of the following blocks: Strided 3x3 convolutions that process the input image. MobileNetV2-style inverted residual blocks for downsampling the resolution of the intermediate feature maps. MobileViT blocks that combine the benefits of Transformers and convolutions. It is presented in the figure below (taken from the original paper): def conv_block(x, filters=16, kernel_size=3, strides=2): conv_layer = layers.Conv2D( filters, kernel_size, strides=strides, activation=tf.nn.swish, padding=\"same\" ) return conv_layer(x) # Reference: https://git.io/JKgtC def inverted_residual_block(x, expanded_channels, output_channels, strides=1): m = layers.Conv2D(expanded_channels, 1, padding=\"same\", use_bias=False)(x) m = layers.BatchNormalization()(m) m = tf.nn.swish(m) if strides == 2: m = layers.ZeroPadding2D(padding=imagenet_utils.correct_pad(m, 3))(m) m = layers.DepthwiseConv2D( 3, strides=strides, padding=\"same\" if strides == 1 else \"valid\", use_bias=False )(m) m = layers.BatchNormalization()(m) m = tf.nn.swish(m) m = layers.Conv2D(output_channels, 1, padding=\"same\", use_bias=False)(m) m = layers.BatchNormalization()(m) if tf.math.equal(x.shape[-1], output_channels) and strides == 1: return layers.Add()([m, x]) return m # Reference: # https://keras.io/examples/vision/image_classification_with_vision_transformer/ def mlp(x, hidden_units, dropout_rate): for units in hidden_units: x = layers.Dense(units, activation=tf.nn.swish)(x) x = layers.Dropout(dropout_rate)(x) return x def transformer_block(x, transformer_layers, projection_dim, num_heads=2): for _ in range(transformer_layers): # Layer normalization 1. x1 = layers.LayerNormalization(epsilon=1e-6)(x) # Create a multi-head attention layer. attention_output = layers.MultiHeadAttention( num_heads=num_heads, key_dim=projection_dim, dropout=0.1 )(x1, x1) # Skip connection 1. x2 = layers.Add()([attention_output, x]) # Layer normalization 2. x3 = layers.LayerNormalization(epsilon=1e-6)(x2) # MLP. x3 = mlp(x3, hidden_units=[x.shape[-1] * 2, x.shape[-1]], dropout_rate=0.1,) # Skip connection 2. x = layers.Add()([x3, x2]) return x def mobilevit_block(x, num_blocks, projection_dim, strides=1): # Local projection with convolutions. local_features = conv_block(x, filters=projection_dim, strides=strides) local_features = conv_block( local_features, filters=projection_dim, kernel_size=1, strides=strides ) # Unfold into patches and then pass through Transformers. num_patches = int((local_features.shape[1] * local_features.shape[2]) / patch_size) non_overlapping_patches = layers.Reshape((patch_size, num_patches, projection_dim))( local_features ) global_features = transformer_block( non_overlapping_patches, num_blocks, projection_dim ) # Fold into conv-like feature-maps. folded_feature_map = layers.Reshape((*local_features.shape[1:-1], projection_dim))( global_features ) # Apply point-wise conv -> concatenate with the input features. folded_feature_map = conv_block( folded_feature_map, filters=x.shape[-1], kernel_size=1, strides=strides ) local_global_features = layers.Concatenate(axis=-1)([x, folded_feature_map]) # Fuse the local and global features using a convoluion layer. local_global_features = conv_block( local_global_features, filters=projection_dim, strides=strides ) return local_global_features More on the MobileViT block: First, the feature representations (A) go through convolution blocks that capture local relationships. The expected shape of a single entry here would be (h, w, num_channels). Then they get unfolded into another vector with shape (p, n, num_channels), where p is the area of a small patch, and n is (h * w) / p. So, we end up with n non-overlapping patches. This unfolded vector is then passed through a Tranformer block that captures global relationships between the patches. The output vector (B) is again folded into a vector of shape (h, w, num_channels) resembling a feature map coming out of convolutions. Vectors A and B are then passed through two more convolutional layers to fuse the local and global representations. Notice how the spatial resolution of the final vector remains unchanged at this point. The authors also present an explanation of how the MobileViT block resembles a convolution block of a CNN. For more details, please refer to the original paper. Next, we combine these blocks together and implement the MobileViT architecture (XXS variant). The following figure (taken from the original paper) presents a schematic representation of the architecture: def create_mobilevit(num_classes=5): inputs = keras.Input((image_size, image_size, 3)) x = layers.Rescaling(scale=1.0 / 255)(inputs) # Initial conv-stem -> MV2 block. x = conv_block(x, filters=16) x = inverted_residual_block( x, expanded_channels=16 * expansion_factor, output_channels=16 ) # Downsampling with MV2 block. x = inverted_residual_block( x, expanded_channels=16 * expansion_factor, output_channels=24, strides=2 ) x = inverted_residual_block( x, expanded_channels=24 * expansion_factor, output_channels=24 ) x = inverted_residual_block( x, expanded_channels=24 * expansion_factor, output_channels=24 ) # First MV2 -> MobileViT block. x = inverted_residual_block( x, expanded_channels=24 * expansion_factor, output_channels=48, strides=2 ) x = mobilevit_block(x, num_blocks=2, projection_dim=64) # Second MV2 -> MobileViT block. x = inverted_residual_block( x, expanded_channels=64 * expansion_factor, output_channels=64, strides=2 ) x = mobilevit_block(x, num_blocks=4, projection_dim=80) # Third MV2 -> MobileViT block. x = inverted_residual_block( x, expanded_channels=80 * expansion_factor, output_channels=80, strides=2 ) x = mobilevit_block(x, num_blocks=3, projection_dim=96) x = conv_block(x, filters=320, kernel_size=1, strides=1) # Classification head. x = layers.GlobalAvgPool2D()(x) outputs = layers.Dense(num_classes, activation=\"softmax\")(x) return keras.Model(inputs, outputs) mobilevit_xxs = create_mobilevit() mobilevit_xxs.summary() Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 256, 256, 3) 0 __________________________________________________________________________________________________ rescaling (Rescaling) (None, 256, 256, 3) 0 input_1[0][0] __________________________________________________________________________________________________ conv2d (Conv2D) (None, 128, 128, 16) 448 rescaling[0][0] __________________________________________________________________________________________________ conv2d_1 (Conv2D) (None, 128, 128, 32) 512 conv2d[0][0] __________________________________________________________________________________________________ batch_normalization (BatchNorma (None, 128, 128, 32) 128 conv2d_1[0][0] __________________________________________________________________________________________________ tf.nn.silu (TFOpLambda) (None, 128, 128, 32) 0 batch_normalization[0][0] __________________________________________________________________________________________________ depthwise_conv2d (DepthwiseConv (None, 128, 128, 32) 288 tf.nn.silu[0][0] __________________________________________________________________________________________________ batch_normalization_1 (BatchNor (None, 128, 128, 32) 128 depthwise_conv2d[0][0] __________________________________________________________________________________________________ tf.nn.silu_1 (TFOpLambda) (None, 128, 128, 32) 0 batch_normalization_1[0][0] __________________________________________________________________________________________________ conv2d_2 (Conv2D) (None, 128, 128, 16) 512 tf.nn.silu_1[0][0] __________________________________________________________________________________________________ batch_normalization_2 (BatchNor (None, 128, 128, 16) 64 conv2d_2[0][0] __________________________________________________________________________________________________ add (Add) (None, 128, 128, 16) 0 batch_normalization_2[0][0] conv2d[0][0] __________________________________________________________________________________________________ conv2d_3 (Conv2D) (None, 128, 128, 32) 512 add[0][0] __________________________________________________________________________________________________ batch_normalization_3 (BatchNor (None, 128, 128, 32) 128 conv2d_3[0][0] __________________________________________________________________________________________________ tf.nn.silu_2 (TFOpLambda) (None, 128, 128, 32) 0 batch_normalization_3[0][0] __________________________________________________________________________________________________ zero_padding2d (ZeroPadding2D) (None, 129, 129, 32) 0 tf.nn.silu_2[0][0] __________________________________________________________________________________________________ depthwise_conv2d_1 (DepthwiseCo (None, 64, 64, 32) 288 zero_padding2d[0][0] __________________________________________________________________________________________________ batch_normalization_4 (BatchNor (None, 64, 64, 32) 128 depthwise_conv2d_1[0][0] __________________________________________________________________________________________________ tf.nn.silu_3 (TFOpLambda) (None, 64, 64, 32) 0 batch_normalization_4[0][0] __________________________________________________________________________________________________ conv2d_4 (Conv2D) (None, 64, 64, 24) 768 tf.nn.silu_3[0][0] __________________________________________________________________________________________________ batch_normalization_5 (BatchNor (None, 64, 64, 24) 96 conv2d_4[0][0] __________________________________________________________________________________________________ conv2d_5 (Conv2D) (None, 64, 64, 48) 1152 batch_normalization_5[0][0] __________________________________________________________________________________________________ batch_normalization_6 (BatchNor (None, 64, 64, 48) 192 conv2d_5[0][0] __________________________________________________________________________________________________ tf.nn.silu_4 (TFOpLambda) (None, 64, 64, 48) 0 batch_normalization_6[0][0] __________________________________________________________________________________________________ depthwise_conv2d_2 (DepthwiseCo (None, 64, 64, 48) 432 tf.nn.silu_4[0][0] __________________________________________________________________________________________________ batch_normalization_7 (BatchNor (None, 64, 64, 48) 192 depthwise_conv2d_2[0][0] __________________________________________________________________________________________________ tf.nn.silu_5 (TFOpLambda) (None, 64, 64, 48) 0 batch_normalization_7[0][0] __________________________________________________________________________________________________ conv2d_6 (Conv2D) (None, 64, 64, 24) 1152 tf.nn.silu_5[0][0] __________________________________________________________________________________________________ batch_normalization_8 (BatchNor (None, 64, 64, 24) 96 conv2d_6[0][0] __________________________________________________________________________________________________ add_1 (Add) (None, 64, 64, 24) 0 batch_normalization_8[0][0] batch_normalization_5[0][0] __________________________________________________________________________________________________ conv2d_7 (Conv2D) (None, 64, 64, 48) 1152 add_1[0][0] __________________________________________________________________________________________________ batch_normalization_9 (BatchNor (None, 64, 64, 48) 192 conv2d_7[0][0] __________________________________________________________________________________________________ tf.nn.silu_6 (TFOpLambda) (None, 64, 64, 48) 0 batch_normalization_9[0][0] __________________________________________________________________________________________________ depthwise_conv2d_3 (DepthwiseCo (None, 64, 64, 48) 432 tf.nn.silu_6[0][0] __________________________________________________________________________________________________ batch_normalization_10 (BatchNo (None, 64, 64, 48) 192 depthwise_conv2d_3[0][0] __________________________________________________________________________________________________ tf.nn.silu_7 (TFOpLambda) (None, 64, 64, 48) 0 batch_normalization_10[0][0] __________________________________________________________________________________________________ conv2d_8 (Conv2D) (None, 64, 64, 24) 1152 tf.nn.silu_7[0][0] __________________________________________________________________________________________________ batch_normalization_11 (BatchNo (None, 64, 64, 24) 96 conv2d_8[0][0] __________________________________________________________________________________________________ add_2 (Add) (None, 64, 64, 24) 0 batch_normalization_11[0][0] add_1[0][0] __________________________________________________________________________________________________ conv2d_9 (Conv2D) (None, 64, 64, 48) 1152 add_2[0][0] __________________________________________________________________________________________________ batch_normalization_12 (BatchNo (None, 64, 64, 48) 192 conv2d_9[0][0] __________________________________________________________________________________________________ tf.nn.silu_8 (TFOpLambda) (None, 64, 64, 48) 0 batch_normalization_12[0][0] __________________________________________________________________________________________________ zero_padding2d_1 (ZeroPadding2D (None, 65, 65, 48) 0 tf.nn.silu_8[0][0] __________________________________________________________________________________________________ depthwise_conv2d_4 (DepthwiseCo (None, 32, 32, 48) 432 zero_padding2d_1[0][0] __________________________________________________________________________________________________ batch_normalization_13 (BatchNo (None, 32, 32, 48) 192 depthwise_conv2d_4[0][0] __________________________________________________________________________________________________ tf.nn.silu_9 (TFOpLambda) (None, 32, 32, 48) 0 batch_normalization_13[0][0] __________________________________________________________________________________________________ conv2d_10 (Conv2D) (None, 32, 32, 48) 2304 tf.nn.silu_9[0][0] __________________________________________________________________________________________________ batch_normalization_14 (BatchNo (None, 32, 32, 48) 192 conv2d_10[0][0] __________________________________________________________________________________________________ conv2d_11 (Conv2D) (None, 32, 32, 64) 27712 batch_normalization_14[0][0] __________________________________________________________________________________________________ conv2d_12 (Conv2D) (None, 32, 32, 64) 4160 conv2d_11[0][0] __________________________________________________________________________________________________ reshape (Reshape) (None, 4, 256, 64) 0 conv2d_12[0][0] __________________________________________________________________________________________________ layer_normalization (LayerNorma (None, 4, 256, 64) 128 reshape[0][0] __________________________________________________________________________________________________ multi_head_attention (MultiHead (None, 4, 256, 64) 33216 layer_normalization[0][0] layer_normalization[0][0] __________________________________________________________________________________________________ add_3 (Add) (None, 4, 256, 64) 0 multi_head_attention[0][0] reshape[0][0] __________________________________________________________________________________________________ layer_normalization_1 (LayerNor (None, 4, 256, 64) 128 add_3[0][0] __________________________________________________________________________________________________ dense (Dense) (None, 4, 256, 128) 8320 layer_normalization_1[0][0] __________________________________________________________________________________________________ dropout (Dropout) (None, 4, 256, 128) 0 dense[0][0] __________________________________________________________________________________________________ dense_1 (Dense) (None, 4, 256, 64) 8256 dropout[0][0] __________________________________________________________________________________________________ dropout_1 (Dropout) (None, 4, 256, 64) 0 dense_1[0][0] __________________________________________________________________________________________________ add_4 (Add) (None, 4, 256, 64) 0 dropout_1[0][0] add_3[0][0] __________________________________________________________________________________________________ layer_normalization_2 (LayerNor (None, 4, 256, 64) 128 add_4[0][0] __________________________________________________________________________________________________ multi_head_attention_1 (MultiHe (None, 4, 256, 64) 33216 layer_normalization_2[0][0] layer_normalization_2[0][0] __________________________________________________________________________________________________ add_5 (Add) (None, 4, 256, 64) 0 multi_head_attention_1[0][0] add_4[0][0] __________________________________________________________________________________________________ layer_normalization_3 (LayerNor (None, 4, 256, 64) 128 add_5[0][0] __________________________________________________________________________________________________ dense_2 (Dense) (None, 4, 256, 128) 8320 layer_normalization_3[0][0] __________________________________________________________________________________________________ dropout_2 (Dropout) (None, 4, 256, 128) 0 dense_2[0][0] __________________________________________________________________________________________________ dense_3 (Dense) (None, 4, 256, 64) 8256 dropout_2[0][0] __________________________________________________________________________________________________ dropout_3 (Dropout) (None, 4, 256, 64) 0 dense_3[0][0] __________________________________________________________________________________________________ add_6 (Add) (None, 4, 256, 64) 0 dropout_3[0][0] add_5[0][0] __________________________________________________________________________________________________ reshape_1 (Reshape) (None, 32, 32, 64) 0 add_6[0][0] __________________________________________________________________________________________________ conv2d_13 (Conv2D) (None, 32, 32, 48) 3120 reshape_1[0][0] __________________________________________________________________________________________________ concatenate (Concatenate) (None, 32, 32, 96) 0 batch_normalization_14[0][0] conv2d_13[0][0] __________________________________________________________________________________________________ conv2d_14 (Conv2D) (None, 32, 32, 64) 55360 concatenate[0][0] __________________________________________________________________________________________________ conv2d_15 (Conv2D) (None, 32, 32, 128) 8192 conv2d_14[0][0] __________________________________________________________________________________________________ batch_normalization_15 (BatchNo (None, 32, 32, 128) 512 conv2d_15[0][0] __________________________________________________________________________________________________ tf.nn.silu_10 (TFOpLambda) (None, 32, 32, 128) 0 batch_normalization_15[0][0] __________________________________________________________________________________________________ zero_padding2d_2 (ZeroPadding2D (None, 33, 33, 128) 0 tf.nn.silu_10[0][0] __________________________________________________________________________________________________ depthwise_conv2d_5 (DepthwiseCo (None, 16, 16, 128) 1152 zero_padding2d_2[0][0] __________________________________________________________________________________________________ batch_normalization_16 (BatchNo (None, 16, 16, 128) 512 depthwise_conv2d_5[0][0] __________________________________________________________________________________________________ tf.nn.silu_11 (TFOpLambda) (None, 16, 16, 128) 0 batch_normalization_16[0][0] __________________________________________________________________________________________________ conv2d_16 (Conv2D) (None, 16, 16, 64) 8192 tf.nn.silu_11[0][0] __________________________________________________________________________________________________ batch_normalization_17 (BatchNo (None, 16, 16, 64) 256 conv2d_16[0][0] __________________________________________________________________________________________________ conv2d_17 (Conv2D) (None, 16, 16, 80) 46160 batch_normalization_17[0][0] __________________________________________________________________________________________________ conv2d_18 (Conv2D) (None, 16, 16, 80) 6480 conv2d_17[0][0] __________________________________________________________________________________________________ reshape_2 (Reshape) (None, 4, 64, 80) 0 conv2d_18[0][0] __________________________________________________________________________________________________ layer_normalization_4 (LayerNor (None, 4, 64, 80) 160 reshape_2[0][0] __________________________________________________________________________________________________ multi_head_attention_2 (MultiHe (None, 4, 64, 80) 51760 layer_normalization_4[0][0] layer_normalization_4[0][0] __________________________________________________________________________________________________ add_7 (Add) (None, 4, 64, 80) 0 multi_head_attention_2[0][0] reshape_2[0][0] __________________________________________________________________________________________________ layer_normalization_5 (LayerNor (None, 4, 64, 80) 160 add_7[0][0] __________________________________________________________________________________________________ dense_4 (Dense) (None, 4, 64, 160) 12960 layer_normalization_5[0][0] __________________________________________________________________________________________________ dropout_4 (Dropout) (None, 4, 64, 160) 0 dense_4[0][0] __________________________________________________________________________________________________ dense_5 (Dense) (None, 4, 64, 80) 12880 dropout_4[0][0] __________________________________________________________________________________________________ dropout_5 (Dropout) (None, 4, 64, 80) 0 dense_5[0][0] __________________________________________________________________________________________________ add_8 (Add) (None, 4, 64, 80) 0 dropout_5[0][0] add_7[0][0] __________________________________________________________________________________________________ layer_normalization_6 (LayerNor (None, 4, 64, 80) 160 add_8[0][0] __________________________________________________________________________________________________ multi_head_attention_3 (MultiHe (None, 4, 64, 80) 51760 layer_normalization_6[0][0] layer_normalization_6[0][0] __________________________________________________________________________________________________ add_9 (Add) (None, 4, 64, 80) 0 multi_head_attention_3[0][0] add_8[0][0] __________________________________________________________________________________________________ layer_normalization_7 (LayerNor (None, 4, 64, 80) 160 add_9[0][0] __________________________________________________________________________________________________ dense_6 (Dense) (None, 4, 64, 160) 12960 layer_normalization_7[0][0] __________________________________________________________________________________________________ dropout_6 (Dropout) (None, 4, 64, 160) 0 dense_6[0][0] __________________________________________________________________________________________________ dense_7 (Dense) (None, 4, 64, 80) 12880 dropout_6[0][0] __________________________________________________________________________________________________ dropout_7 (Dropout) (None, 4, 64, 80) 0 dense_7[0][0] __________________________________________________________________________________________________ add_10 (Add) (None, 4, 64, 80) 0 dropout_7[0][0] add_9[0][0] __________________________________________________________________________________________________ layer_normalization_8 (LayerNor (None, 4, 64, 80) 160 add_10[0][0] __________________________________________________________________________________________________ multi_head_attention_4 (MultiHe (None, 4, 64, 80) 51760 layer_normalization_8[0][0] layer_normalization_8[0][0] __________________________________________________________________________________________________ add_11 (Add) (None, 4, 64, 80) 0 multi_head_attention_4[0][0] add_10[0][0] __________________________________________________________________________________________________ layer_normalization_9 (LayerNor (None, 4, 64, 80) 160 add_11[0][0] __________________________________________________________________________________________________ dense_8 (Dense) (None, 4, 64, 160) 12960 layer_normalization_9[0][0] __________________________________________________________________________________________________ dropout_8 (Dropout) (None, 4, 64, 160) 0 dense_8[0][0] __________________________________________________________________________________________________ dense_9 (Dense) (None, 4, 64, 80) 12880 dropout_8[0][0] __________________________________________________________________________________________________ dropout_9 (Dropout) (None, 4, 64, 80) 0 dense_9[0][0] __________________________________________________________________________________________________ add_12 (Add) (None, 4, 64, 80) 0 dropout_9[0][0] add_11[0][0] __________________________________________________________________________________________________ layer_normalization_10 (LayerNo (None, 4, 64, 80) 160 add_12[0][0] __________________________________________________________________________________________________ multi_head_attention_5 (MultiHe (None, 4, 64, 80) 51760 layer_normalization_10[0][0] layer_normalization_10[0][0] __________________________________________________________________________________________________ add_13 (Add) (None, 4, 64, 80) 0 multi_head_attention_5[0][0] add_12[0][0] __________________________________________________________________________________________________ layer_normalization_11 (LayerNo (None, 4, 64, 80) 160 add_13[0][0] __________________________________________________________________________________________________ dense_10 (Dense) (None, 4, 64, 160) 12960 layer_normalization_11[0][0] __________________________________________________________________________________________________ dropout_10 (Dropout) (None, 4, 64, 160) 0 dense_10[0][0] __________________________________________________________________________________________________ dense_11 (Dense) (None, 4, 64, 80) 12880 dropout_10[0][0] __________________________________________________________________________________________________ dropout_11 (Dropout) (None, 4, 64, 80) 0 dense_11[0][0] __________________________________________________________________________________________________ add_14 (Add) (None, 4, 64, 80) 0 dropout_11[0][0] add_13[0][0] __________________________________________________________________________________________________ reshape_3 (Reshape) (None, 16, 16, 80) 0 add_14[0][0] __________________________________________________________________________________________________ conv2d_19 (Conv2D) (None, 16, 16, 64) 5184 reshape_3[0][0] __________________________________________________________________________________________________ concatenate_1 (Concatenate) (None, 16, 16, 128) 0 batch_normalization_17[0][0] conv2d_19[0][0] __________________________________________________________________________________________________ conv2d_20 (Conv2D) (None, 16, 16, 80) 92240 concatenate_1[0][0] __________________________________________________________________________________________________ conv2d_21 (Conv2D) (None, 16, 16, 160) 12800 conv2d_20[0][0] __________________________________________________________________________________________________ batch_normalization_18 (BatchNo (None, 16, 16, 160) 640 conv2d_21[0][0] __________________________________________________________________________________________________ tf.nn.silu_12 (TFOpLambda) (None, 16, 16, 160) 0 batch_normalization_18[0][0] __________________________________________________________________________________________________ zero_padding2d_3 (ZeroPadding2D (None, 17, 17, 160) 0 tf.nn.silu_12[0][0] __________________________________________________________________________________________________ depthwise_conv2d_6 (DepthwiseCo (None, 8, 8, 160) 1440 zero_padding2d_3[0][0] __________________________________________________________________________________________________ batch_normalization_19 (BatchNo (None, 8, 8, 160) 640 depthwise_conv2d_6[0][0] __________________________________________________________________________________________________ tf.nn.silu_13 (TFOpLambda) (None, 8, 8, 160) 0 batch_normalization_19[0][0] __________________________________________________________________________________________________ conv2d_22 (Conv2D) (None, 8, 8, 80) 12800 tf.nn.silu_13[0][0] __________________________________________________________________________________________________ batch_normalization_20 (BatchNo (None, 8, 8, 80) 320 conv2d_22[0][0] __________________________________________________________________________________________________ conv2d_23 (Conv2D) (None, 8, 8, 96) 69216 batch_normalization_20[0][0] __________________________________________________________________________________________________ conv2d_24 (Conv2D) (None, 8, 8, 96) 9312 conv2d_23[0][0] __________________________________________________________________________________________________ reshape_4 (Reshape) (None, 4, 16, 96) 0 conv2d_24[0][0] __________________________________________________________________________________________________ layer_normalization_12 (LayerNo (None, 4, 16, 96) 192 reshape_4[0][0] __________________________________________________________________________________________________ multi_head_attention_6 (MultiHe (None, 4, 16, 96) 74400 layer_normalization_12[0][0] layer_normalization_12[0][0] __________________________________________________________________________________________________ add_15 (Add) (None, 4, 16, 96) 0 multi_head_attention_6[0][0] reshape_4[0][0] __________________________________________________________________________________________________ layer_normalization_13 (LayerNo (None, 4, 16, 96) 192 add_15[0][0] __________________________________________________________________________________________________ dense_12 (Dense) (None, 4, 16, 192) 18624 layer_normalization_13[0][0] __________________________________________________________________________________________________ dropout_12 (Dropout) (None, 4, 16, 192) 0 dense_12[0][0] __________________________________________________________________________________________________ dense_13 (Dense) (None, 4, 16, 96) 18528 dropout_12[0][0] __________________________________________________________________________________________________ dropout_13 (Dropout) (None, 4, 16, 96) 0 dense_13[0][0] __________________________________________________________________________________________________ add_16 (Add) (None, 4, 16, 96) 0 dropout_13[0][0] add_15[0][0] __________________________________________________________________________________________________ layer_normalization_14 (LayerNo (None, 4, 16, 96) 192 add_16[0][0] __________________________________________________________________________________________________ multi_head_attention_7 (MultiHe (None, 4, 16, 96) 74400 layer_normalization_14[0][0] layer_normalization_14[0][0] __________________________________________________________________________________________________ add_17 (Add) (None, 4, 16, 96) 0 multi_head_attention_7[0][0] add_16[0][0] __________________________________________________________________________________________________ layer_normalization_15 (LayerNo (None, 4, 16, 96) 192 add_17[0][0] __________________________________________________________________________________________________ dense_14 (Dense) (None, 4, 16, 192) 18624 layer_normalization_15[0][0] __________________________________________________________________________________________________ dropout_14 (Dropout) (None, 4, 16, 192) 0 dense_14[0][0] __________________________________________________________________________________________________ dense_15 (Dense) (None, 4, 16, 96) 18528 dropout_14[0][0] __________________________________________________________________________________________________ dropout_15 (Dropout) (None, 4, 16, 96) 0 dense_15[0][0] __________________________________________________________________________________________________ add_18 (Add) (None, 4, 16, 96) 0 dropout_15[0][0] add_17[0][0] __________________________________________________________________________________________________ layer_normalization_16 (LayerNo (None, 4, 16, 96) 192 add_18[0][0] __________________________________________________________________________________________________ multi_head_attention_8 (MultiHe (None, 4, 16, 96) 74400 layer_normalization_16[0][0] layer_normalization_16[0][0] __________________________________________________________________________________________________ add_19 (Add) (None, 4, 16, 96) 0 multi_head_attention_8[0][0] add_18[0][0] __________________________________________________________________________________________________ layer_normalization_17 (LayerNo (None, 4, 16, 96) 192 add_19[0][0] __________________________________________________________________________________________________ dense_16 (Dense) (None, 4, 16, 192) 18624 layer_normalization_17[0][0] __________________________________________________________________________________________________ dropout_16 (Dropout) (None, 4, 16, 192) 0 dense_16[0][0] __________________________________________________________________________________________________ dense_17 (Dense) (None, 4, 16, 96) 18528 dropout_16[0][0] __________________________________________________________________________________________________ dropout_17 (Dropout) (None, 4, 16, 96) 0 dense_17[0][0] __________________________________________________________________________________________________ add_20 (Add) (None, 4, 16, 96) 0 dropout_17[0][0] add_19[0][0] __________________________________________________________________________________________________ reshape_5 (Reshape) (None, 8, 8, 96) 0 add_20[0][0] __________________________________________________________________________________________________ conv2d_25 (Conv2D) (None, 8, 8, 80) 7760 reshape_5[0][0] __________________________________________________________________________________________________ concatenate_2 (Concatenate) (None, 8, 8, 160) 0 batch_normalization_20[0][0] conv2d_25[0][0] __________________________________________________________________________________________________ conv2d_26 (Conv2D) (None, 8, 8, 96) 138336 concatenate_2[0][0] __________________________________________________________________________________________________ conv2d_27 (Conv2D) (None, 8, 8, 320) 31040 conv2d_26[0][0] __________________________________________________________________________________________________ global_average_pooling2d (Globa (None, 320) 0 conv2d_27[0][0] __________________________________________________________________________________________________ dense_18 (Dense) (None, 5) 1605 global_average_pooling2d[0][0] ================================================================================================== Total params: 1,307,621 Trainable params: 1,305,077 Non-trainable params: 2,544 __________________________________________________________________________________________________ Dataset preparation We will be using the tf_flowers dataset to demonstrate the model. Unlike other Transformer-based architectures, MobileViT uses a simple augmentation pipeline primarily because it has the properties of a CNN. batch_size = 64 auto = tf.data.AUTOTUNE resize_bigger = 280 num_classes = 5 def preprocess_dataset(is_training=True): def _pp(image, label): if is_training: # Resize to a bigger spatial resolution and take the random # crops. image = tf.image.resize(image, (resize_bigger, resize_bigger)) image = tf.image.random_crop(image, (image_size, image_size, 3)) image = tf.image.random_flip_left_right(image) else: image = tf.image.resize(image, (image_size, image_size)) label = tf.one_hot(label, depth=num_classes) return image, label return _pp def prepare_dataset(dataset, is_training=True): if is_training: dataset = dataset.shuffle(batch_size * 10) dataset = dataset.map(preprocess_dataset(is_training), num_parallel_calls=auto) return dataset.batch(batch_size).prefetch(auto) The authors use a multi-scale data sampler to help the model learn representations of varied scales. In this example, we discard this part. Load and prepare the dataset train_dataset, val_dataset = tfds.load( \"tf_flowers\", split=[\"train[:90%]\", \"train[90%:]\"], as_supervised=True ) num_train = train_dataset.cardinality() num_val = val_dataset.cardinality() print(f\"Number of training examples: {num_train}\") print(f\"Number of validation examples: {num_val}\") train_dataset = prepare_dataset(train_dataset, is_training=True) val_dataset = prepare_dataset(val_dataset, is_training=False) Number of training examples: 3303 Number of validation examples: 367 Train a MobileViT (XXS) model learning_rate = 0.002 label_smoothing_factor = 0.1 epochs = 30 optimizer = keras.optimizers.Adam(learning_rate=learning_rate) loss_fn = keras.losses.CategoricalCrossentropy(label_smoothing=label_smoothing_factor) def run_experiment(epochs=epochs): mobilevit_xxs = create_mobilevit(num_classes=num_classes) mobilevit_xxs.compile(optimizer=optimizer, loss=loss_fn, metrics=[\"accuracy\"]) checkpoint_filepath = \"/tmp/checkpoint\" checkpoint_callback = keras.callbacks.ModelCheckpoint( checkpoint_filepath, monitor=\"val_accuracy\", save_best_only=True, save_weights_only=True, ) mobilevit_xxs.fit( train_dataset, validation_data=val_dataset, epochs=epochs, callbacks=[checkpoint_callback], ) mobilevit_xxs.load_weights(checkpoint_filepath) _, accuracy = mobilevit_xxs.evaluate(val_dataset) print(f\"Validation accuracy: {round(accuracy * 100, 2)}%\") return mobilevit_xxs mobilevit_xxs = run_experiment() Epoch 1/30 52/52 [==============================] - 47s 459ms/step - loss: 1.3397 - accuracy: 0.4832 - val_loss: 1.7250 - val_accuracy: 0.1662 Epoch 2/30 52/52 [==============================] - 21s 404ms/step - loss: 1.1167 - accuracy: 0.6210 - val_loss: 1.9844 - val_accuracy: 0.1907 Epoch 3/30 52/52 [==============================] - 21s 403ms/step - loss: 1.0217 - accuracy: 0.6709 - val_loss: 1.8187 - val_accuracy: 0.1907 Epoch 4/30 52/52 [==============================] - 21s 409ms/step - loss: 0.9682 - accuracy: 0.7048 - val_loss: 2.0329 - val_accuracy: 0.1907 Epoch 5/30 52/52 [==============================] - 21s 408ms/step - loss: 0.9552 - accuracy: 0.7196 - val_loss: 2.1150 - val_accuracy: 0.1907 Epoch 6/30 52/52 [==============================] - 21s 407ms/step - loss: 0.9186 - accuracy: 0.7318 - val_loss: 2.9713 - val_accuracy: 0.1907 Epoch 7/30 52/52 [==============================] - 21s 407ms/step - loss: 0.8986 - accuracy: 0.7457 - val_loss: 3.2062 - val_accuracy: 0.1907 Epoch 8/30 52/52 [==============================] - 21s 408ms/step - loss: 0.8831 - accuracy: 0.7542 - val_loss: 3.8631 - val_accuracy: 0.1907 Epoch 9/30 52/52 [==============================] - 21s 408ms/step - loss: 0.8433 - accuracy: 0.7714 - val_loss: 1.8029 - val_accuracy: 0.3542 Epoch 10/30 52/52 [==============================] - 21s 408ms/step - loss: 0.8489 - accuracy: 0.7763 - val_loss: 1.7920 - val_accuracy: 0.4796 Epoch 11/30 52/52 [==============================] - 21s 409ms/step - loss: 0.8256 - accuracy: 0.7884 - val_loss: 1.4992 - val_accuracy: 0.5477 Epoch 12/30 52/52 [==============================] - 21s 407ms/step - loss: 0.7859 - accuracy: 0.8123 - val_loss: 0.9236 - val_accuracy: 0.7330 Epoch 13/30 52/52 [==============================] - 21s 409ms/step - loss: 0.7702 - accuracy: 0.8159 - val_loss: 0.8059 - val_accuracy: 0.8011 Epoch 14/30 52/52 [==============================] - 21s 403ms/step - loss: 0.7670 - accuracy: 0.8153 - val_loss: 1.1535 - val_accuracy: 0.7084 Epoch 15/30 52/52 [==============================] - 21s 408ms/step - loss: 0.7332 - accuracy: 0.8344 - val_loss: 0.7746 - val_accuracy: 0.8147 Epoch 16/30 52/52 [==============================] - 21s 404ms/step - loss: 0.7284 - accuracy: 0.8335 - val_loss: 1.0342 - val_accuracy: 0.7330 Epoch 17/30 52/52 [==============================] - 21s 409ms/step - loss: 0.7484 - accuracy: 0.8262 - val_loss: 1.0523 - val_accuracy: 0.7112 Epoch 18/30 52/52 [==============================] - 21s 408ms/step - loss: 0.7209 - accuracy: 0.8450 - val_loss: 0.8146 - val_accuracy: 0.8174 Epoch 19/30 52/52 [==============================] - 21s 409ms/step - loss: 0.7141 - accuracy: 0.8435 - val_loss: 0.8016 - val_accuracy: 0.7875 Epoch 20/30 52/52 [==============================] - 21s 410ms/step - loss: 0.7075 - accuracy: 0.8435 - val_loss: 0.9352 - val_accuracy: 0.7439 Epoch 21/30 52/52 [==============================] - 21s 406ms/step - loss: 0.7066 - accuracy: 0.8504 - val_loss: 1.0171 - val_accuracy: 0.7139 Epoch 22/30 52/52 [==============================] - 21s 405ms/step - loss: 0.6913 - accuracy: 0.8532 - val_loss: 0.7059 - val_accuracy: 0.8610 Epoch 23/30 52/52 [==============================] - 21s 408ms/step - loss: 0.6681 - accuracy: 0.8671 - val_loss: 0.8007 - val_accuracy: 0.8147 Epoch 24/30 52/52 [==============================] - 21s 409ms/step - loss: 0.6636 - accuracy: 0.8747 - val_loss: 0.9490 - val_accuracy: 0.7302 Epoch 25/30 52/52 [==============================] - 21s 408ms/step - loss: 0.6637 - accuracy: 0.8722 - val_loss: 0.6913 - val_accuracy: 0.8556 Epoch 26/30 52/52 [==============================] - 21s 406ms/step - loss: 0.6443 - accuracy: 0.8837 - val_loss: 1.0483 - val_accuracy: 0.7139 Epoch 27/30 52/52 [==============================] - 21s 407ms/step - loss: 0.6555 - accuracy: 0.8695 - val_loss: 0.9448 - val_accuracy: 0.7602 Epoch 28/30 52/52 [==============================] - 21s 409ms/step - loss: 0.6409 - accuracy: 0.8807 - val_loss: 0.9337 - val_accuracy: 0.7302 Epoch 29/30 52/52 [==============================] - 21s 408ms/step - loss: 0.6300 - accuracy: 0.8910 - val_loss: 0.7461 - val_accuracy: 0.8256 Epoch 30/30 52/52 [==============================] - 21s 408ms/step - loss: 0.6093 - accuracy: 0.8968 - val_loss: 0.8651 - val_accuracy: 0.7766 6/6 [==============================] - 0s 65ms/step - loss: 0.7059 - accuracy: 0.8610 Validation accuracy: 86.1% Results and TFLite conversion With about one million parameters, getting to ~85% top-1 accuracy on 256x256 resolution is a strong result. This MobileViT mobile is fully compatible with TensorFlow Lite (TFLite) and can be converted with the following code: # Serialize the model as a SavedModel. mobilevit_xxs.save(\"mobilevit_xxs\") # Convert to TFLite. This form of quantization is called # post-training dynamic-range quantization in TFLite. converter = tf.lite.TFLiteConverter.from_saved_model(\"mobilevit_xxs\") converter.optimizations = [tf.lite.Optimize.DEFAULT] converter.target_spec.supported_ops = [ tf.lite.OpsSet.TFLITE_BUILTINS, # Enable TensorFlow Lite ops. tf.lite.OpsSet.SELECT_TF_OPS, # Enable TensorFlow ops. ] tflite_model = converter.convert() open(\"mobilevit_xxs.tflite\", \"wb\").write(tflite_model) To learn more about different quantization recipes available in TFLite and running inference with TFLite models, check out this official resource. How to obtain integrated gradients for a classification model. Integrated Gradients Integrated Gradients is a technique for attributing a classification model's prediction to its input features. It is a model interpretability technique: you can use it to visualize the relationship between input features and model predictions. Integrated Gradients is a variation on computing the gradient of the prediction output with regard to features of the input. To compute integrated gradients, we need to perform the following steps: Identify the input and the output. In our case, the input is an image and the output is the last layer of our model (dense layer with softmax activation). Compute which features are important to a neural network when making a prediction on a particular data point. To identify these features, we need to choose a baseline input. A baseline input can be a black image (all pixel values set to zero) or random noise. The shape of the baseline input needs to be the same as our input image, e.g. (299, 299, 3). Interpolate the baseline for a given number of steps. The number of steps represents the steps we need in the gradient approximation for a given input image. The number of steps is a hyperparameter. The authors recommend using anywhere between 20 and 1000 steps. Preprocess these interpolated images and do a forward pass. Get the gradients for these interpolated images. Approximate the gradients integral using the trapezoidal rule. To read in-depth about integrated gradients and why this method works, consider reading this excellent article. References: Integrated Gradients original paper Original implementation Setup import numpy as np import matplotlib.pyplot as plt from scipy import ndimage from IPython.display import Image import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.applications import xception # Size of the input image img_size = (299, 299, 3) # Load Xception model with imagenet weights model = xception.Xception(weights=\"imagenet\") # The local path to our target image img_path = keras.utils.get_file(\"elephant.jpg\", \"https://i.imgur.com/Bvro0YD.png\") display(Image(img_path)) Downloading data from https://i.imgur.com/Bvro0YD.png 4218880/4217496 [==============================] - 0s 0us/step jpeg Integrated Gradients algorithm def get_img_array(img_path, size=(299, 299)): # `img` is a PIL image of size 299x299 img = keras.preprocessing.image.load_img(img_path, target_size=size) # `array` is a float32 Numpy array of shape (299, 299, 3) array = keras.preprocessing.image.img_to_array(img) # We add a dimension to transform our array into a \"batch\" # of size (1, 299, 299, 3) array = np.expand_dims(array, axis=0) return array def get_gradients(img_input, top_pred_idx): \"\"\"Computes the gradients of outputs w.r.t input image. Args: img_input: 4D image tensor top_pred_idx: Predicted label for the input image Returns: Gradients of the predictions w.r.t img_input \"\"\" images = tf.cast(img_input, tf.float32) with tf.GradientTape() as tape: tape.watch(images) preds = model(images) top_class = preds[:, top_pred_idx] grads = tape.gradient(top_class, images) return grads def get_integrated_gradients(img_input, top_pred_idx, baseline=None, num_steps=50): \"\"\"Computes Integrated Gradients for a predicted label. Args: img_input (ndarray): Original image top_pred_idx: Predicted label for the input image baseline (ndarray): The baseline image to start with for interpolation num_steps: Number of interpolation steps between the baseline and the input used in the computation of integrated gradients. These steps along determine the integral approximation error. By default, num_steps is set to 50. Returns: Integrated gradients w.r.t input image \"\"\" # If baseline is not provided, start with a black image # having same size as the input image. if baseline is None: baseline = np.zeros(img_size).astype(np.float32) else: baseline = baseline.astype(np.float32) # 1. Do interpolation. img_input = img_input.astype(np.float32) interpolated_image = [ baseline + (step / num_steps) * (img_input - baseline) for step in range(num_steps + 1) ] interpolated_image = np.array(interpolated_image).astype(np.float32) # 2. Preprocess the interpolated images interpolated_image = xception.preprocess_input(interpolated_image) # 3. Get the gradients grads = [] for i, img in enumerate(interpolated_image): img = tf.expand_dims(img, axis=0) grad = get_gradients(img, top_pred_idx=top_pred_idx) grads.append(grad[0]) grads = tf.convert_to_tensor(grads, dtype=tf.float32) # 4. Approximate the integral using the trapezoidal rule grads = (grads[:-1] + grads[1:]) / 2.0 avg_grads = tf.reduce_mean(grads, axis=0) # 5. Calculate integrated gradients and return integrated_grads = (img_input - baseline) * avg_grads return integrated_grads def random_baseline_integrated_gradients( img_input, top_pred_idx, num_steps=50, num_runs=2 ): \"\"\"Generates a number of random baseline images. Args: img_input (ndarray): 3D image top_pred_idx: Predicted label for the input image num_steps: Number of interpolation steps between the baseline and the input used in the computation of integrated gradients. These steps along determine the integral approximation error. By default, num_steps is set to 50. num_runs: number of baseline images to generate Returns: Averaged integrated gradients for `num_runs` baseline images \"\"\" # 1. List to keep track of Integrated Gradients (IG) for all the images integrated_grads = [] # 2. Get the integrated gradients for all the baselines for run in range(num_runs): baseline = np.random.random(img_size) * 255 igrads = get_integrated_gradients( img_input=img_input, top_pred_idx=top_pred_idx, baseline=baseline, num_steps=num_steps, ) integrated_grads.append(igrads) # 3. Return the average integrated gradients for the image integrated_grads = tf.convert_to_tensor(integrated_grads) return tf.reduce_mean(integrated_grads, axis=0) Helper class for visualizing gradients and integrated gradients class GradVisualizer: \"\"\"Plot gradients of the outputs w.r.t an input image.\"\"\" def __init__(self, positive_channel=None, negative_channel=None): if positive_channel is None: self.positive_channel = [0, 255, 0] else: self.positive_channel = positive_channel if negative_channel is None: self.negative_channel = [255, 0, 0] else: self.negative_channel = negative_channel def apply_polarity(self, attributions, polarity): if polarity == \"positive\": return np.clip(attributions, 0, 1) else: return np.clip(attributions, -1, 0) def apply_linear_transformation( self, attributions, clip_above_percentile=99.9, clip_below_percentile=70.0, lower_end=0.2, ): # 1. Get the thresholds m = self.get_thresholded_attributions( attributions, percentage=100 - clip_above_percentile ) e = self.get_thresholded_attributions( attributions, percentage=100 - clip_below_percentile ) # 2. Transform the attributions by a linear function f(x) = a*x + b such that # f(m) = 1.0 and f(e) = lower_end transformed_attributions = (1 - lower_end) * (np.abs(attributions) - e) / ( m - e ) + lower_end # 3. Make sure that the sign of transformed attributions is the same as original attributions transformed_attributions *= np.sign(attributions) # 4. Only keep values that are bigger than the lower_end transformed_attributions *= transformed_attributions >= lower_end # 5. Clip values and return transformed_attributions = np.clip(transformed_attributions, 0.0, 1.0) return transformed_attributions def get_thresholded_attributions(self, attributions, percentage): if percentage == 100.0: return np.min(attributions) # 1. Flatten the attributions flatten_attr = attributions.flatten() # 2. Get the sum of the attributions total = np.sum(flatten_attr) # 3. Sort the attributions from largest to smallest. sorted_attributions = np.sort(np.abs(flatten_attr))[::-1] # 4. Calculate the percentage of the total sum that each attribution # and the values about it contribute. cum_sum = 100.0 * np.cumsum(sorted_attributions) / total # 5. Threshold the attributions by the percentage indices_to_consider = np.where(cum_sum >= percentage)[0][0] # 6. Select the desired attributions and return attributions = sorted_attributions[indices_to_consider] return attributions def binarize(self, attributions, threshold=0.001): return attributions > threshold def morphological_cleanup_fn(self, attributions, structure=np.ones((4, 4))): closed = ndimage.grey_closing(attributions, structure=structure) opened = ndimage.grey_opening(closed, structure=structure) return opened def draw_outlines( self, attributions, percentage=90, connected_component_structure=np.ones((3, 3)) ): # 1. Binarize the attributions. attributions = self.binarize(attributions) # 2. Fill the gaps attributions = ndimage.binary_fill_holes(attributions) # 3. Compute connected components connected_components, num_comp = ndimage.measurements.label( attributions, structure=connected_component_structure ) # 4. Sum up the attributions for each component total = np.sum(attributions[connected_components > 0]) component_sums = [] for comp in range(1, num_comp + 1): mask = connected_components == comp component_sum = np.sum(attributions[mask]) component_sums.append((component_sum, mask)) # 5. Compute the percentage of top components to keep sorted_sums_and_masks = sorted(component_sums, key=lambda x: x[0], reverse=True) sorted_sums = list(zip(*sorted_sums_and_masks))[0] cumulative_sorted_sums = np.cumsum(sorted_sums) cutoff_threshold = percentage * total / 100 cutoff_idx = np.where(cumulative_sorted_sums >= cutoff_threshold)[0][0] if cutoff_idx > 2: cutoff_idx = 2 # 6. Set the values for the kept components border_mask = np.zeros_like(attributions) for i in range(cutoff_idx + 1): border_mask[sorted_sums_and_masks[i][1]] = 1 # 7. Make the mask hollow and show only the border eroded_mask = ndimage.binary_erosion(border_mask, iterations=1) border_mask[eroded_mask] = 0 # 8. Return the outlined mask return border_mask def process_grads( self, image, attributions, polarity=\"positive\", clip_above_percentile=99.9, clip_below_percentile=0, morphological_cleanup=False, structure=np.ones((3, 3)), outlines=False, outlines_component_percentage=90, overlay=True, ): if polarity not in [\"positive\", \"negative\"]: raise ValueError( f\"\"\" Allowed polarity values: 'positive' or 'negative' but provided {polarity}\"\"\" ) if clip_above_percentile < 0 or clip_above_percentile > 100: raise ValueError(\"clip_above_percentile must be in [0, 100]\") if clip_below_percentile < 0 or clip_below_percentile > 100: raise ValueError(\"clip_below_percentile must be in [0, 100]\") # 1. Apply polarity if polarity == \"positive\": attributions = self.apply_polarity(attributions, polarity=polarity) channel = self.positive_channel else: attributions = self.apply_polarity(attributions, polarity=polarity) attributions = np.abs(attributions) channel = self.negative_channel # 2. Take average over the channels attributions = np.average(attributions, axis=2) # 3. Apply linear transformation to the attributions attributions = self.apply_linear_transformation( attributions, clip_above_percentile=clip_above_percentile, clip_below_percentile=clip_below_percentile, lower_end=0.0, ) # 4. Cleanup if morphological_cleanup: attributions = self.morphological_cleanup_fn( attributions, structure=structure ) # 5. Draw the outlines if outlines: attributions = self.draw_outlines( attributions, percentage=outlines_component_percentage ) # 6. Expand the channel axis and convert to RGB attributions = np.expand_dims(attributions, 2) * channel # 7.Superimpose on the original image if overlay: attributions = np.clip((attributions * 0.8 + image), 0, 255) return attributions def visualize( self, image, gradients, integrated_gradients, polarity=\"positive\", clip_above_percentile=99.9, clip_below_percentile=0, morphological_cleanup=False, structure=np.ones((3, 3)), outlines=False, outlines_component_percentage=90, overlay=True, figsize=(15, 8), ): # 1. Make two copies of the original image img1 = np.copy(image) img2 = np.copy(image) # 2. Process the normal gradients grads_attr = self.process_grads( image=img1, attributions=gradients, polarity=polarity, clip_above_percentile=clip_above_percentile, clip_below_percentile=clip_below_percentile, morphological_cleanup=morphological_cleanup, structure=structure, outlines=outlines, outlines_component_percentage=outlines_component_percentage, overlay=overlay, ) # 3. Process the integrated gradients igrads_attr = self.process_grads( image=img2, attributions=integrated_gradients, polarity=polarity, clip_above_percentile=clip_above_percentile, clip_below_percentile=clip_below_percentile, morphological_cleanup=morphological_cleanup, structure=structure, outlines=outlines, outlines_component_percentage=outlines_component_percentage, overlay=overlay, ) _, ax = plt.subplots(1, 3, figsize=figsize) ax[0].imshow(image) ax[1].imshow(grads_attr.astype(np.uint8)) ax[2].imshow(igrads_attr.astype(np.uint8)) ax[0].set_title(\"Input\") ax[1].set_title(\"Normal gradients\") ax[2].set_title(\"Integrated gradients\") plt.show() Let's test-drive it # 1. Convert the image to numpy array img = get_img_array(img_path) # 2. Keep a copy of the original image orig_img = np.copy(img[0]).astype(np.uint8) # 3. Preprocess the image img_processed = tf.cast(xception.preprocess_input(img), dtype=tf.float32) # 4. Get model predictions preds = model.predict(img_processed) top_pred_idx = tf.argmax(preds[0]) print(\"Predicted:\", top_pred_idx, xception.decode_predictions(preds, top=1)[0]) # 5. Get the gradients of the last layer for the predicted label grads = get_gradients(img_processed, top_pred_idx=top_pred_idx) # 6. Get the integrated gradients igrads = random_baseline_integrated_gradients( np.copy(orig_img), top_pred_idx=top_pred_idx, num_steps=50, num_runs=2 ) # 7. Process the gradients and plot vis = GradVisualizer() vis.visualize( image=orig_img, gradients=grads[0].numpy(), integrated_gradients=igrads.numpy(), clip_above_percentile=99, clip_below_percentile=0, ) vis.visualize( image=orig_img, gradients=grads[0].numpy(), integrated_gradients=igrads.numpy(), clip_above_percentile=95, clip_below_percentile=28, morphological_cleanup=True, outlines=True, ) Predicted: tf.Tensor(386, shape=(), dtype=int64) [('n02504458', 'African_elephant', 0.8871446)] Implement a depth estimation model with a convnet. Introduction Depth estimation is a crucial step towards inferring scene geometry from 2D images. The goal in monocular depth estimation is to predict the depth value of each pixel or inferring depth information, given only a single RGB image as input. This example will show an approach to build a depth estimation model with a convnet and simple loss functions. depth Setup import os import sys import tensorflow as tf from tensorflow.keras import layers import pandas as pd import numpy as np import cv2 import matplotlib.pyplot as plt tf.random.set_seed(123) Downloading the dataset We will be using the dataset DIODE: A Dense Indoor and Outdoor Depth Dataset for this tutorial. However, we use the validation set generating training and evaluation subsets for our model. The reason we use the validation set rather than the training set of the original dataset is because the training set consists of 81GB of data, which is challenging to download compared to the validation set which is only 2.6GB. Other datasets that you could use are NYU-v2 and KITTI. annotation_folder = \"/dataset/\" if not os.path.exists(os.path.abspath(\".\") + annotation_folder): annotation_zip = tf.keras.utils.get_file( \"val.tar.gz\", cache_subdir=os.path.abspath(\".\"), origin=\"http://diode-dataset.s3.amazonaws.com/val.tar.gz\", extract=True, ) Downloading data from http://diode-dataset.s3.amazonaws.com/val.tar.gz 2774630400/2774625282 [==============================] - 90s 0us/step 2774638592/2774625282 [==============================] - 90s 0us/step Preparing the dataset We only use the indoor images to train our depth estimation model. path = \"val/indoors\" filelist = [] for root, dirs, files in os.walk(path): for file in files: filelist.append(os.path.join(root, file)) filelist.sort() data = { \"image\": [x for x in filelist if x.endswith(\".png\")], \"depth\": [x for x in filelist if x.endswith(\"_depth.npy\")], \"mask\": [x for x in filelist if x.endswith(\"_depth_mask.npy\")], } df = pd.DataFrame(data) df = df.sample(frac=1, random_state=42) Preparing hyperparameters HEIGHT = 256 WIDTH = 256 LR = 0.0002 EPOCHS = 30 BATCH_SIZE = 32 Building a data pipeline The pipeline takes a dataframe containing the path for the RGB images, as well as the depth and depth mask files. It reads and resize the RGB images. It reads the depth and depth mask files, process them to generate the depth map image and resize it. It returns the RGB images and the depth map images for a batch. class DataGenerator(tf.keras.utils.Sequence): def __init__(self, data, batch_size=6, dim=(768, 1024), n_channels=3, shuffle=True): \"\"\" Initialization \"\"\" self.data = data self.indices = self.data.index.tolist() self.dim = dim self.n_channels = n_channels self.batch_size = batch_size self.shuffle = shuffle self.min_depth = 0.1 self.on_epoch_end() def __len__(self): return int(np.ceil(len(self.data) / self.batch_size)) def __getitem__(self, index): if (index + 1) * self.batch_size > len(self.indices): self.batch_size = len(self.indices) - index * self.batch_size # Generate one batch of data # Generate indices of the batch index = self.indices[index * self.batch_size : (index + 1) * self.batch_size] # Find list of IDs batch = [self.indices[k] for k in index] x, y = self.data_generation(batch) return x, y def on_epoch_end(self): \"\"\" Updates indexes after each epoch \"\"\" self.index = np.arange(len(self.indices)) if self.shuffle == True: np.random.shuffle(self.index) def load(self, image_path, depth_map, mask): \"\"\"Load input and target image.\"\"\" image_ = cv2.imread(image_path) image_ = cv2.cvtColor(image_, cv2.COLOR_BGR2RGB) image_ = cv2.resize(image_, self.dim) image_ = tf.image.convert_image_dtype(image_, tf.float32) depth_map = np.load(depth_map).squeeze() mask = np.load(mask) mask = mask > 0 max_depth = min(300, np.percentile(depth_map, 99)) depth_map = np.clip(depth_map, self.min_depth, max_depth) depth_map = np.log(depth_map, where=mask) depth_map = np.ma.masked_where(~mask, depth_map) depth_map = np.clip(depth_map, 0.1, np.log(max_depth)) depth_map = cv2.resize(depth_map, self.dim) depth_map = np.expand_dims(depth_map, axis=2) depth_map = tf.image.convert_image_dtype(depth_map, tf.float32) return image_, depth_map def data_generation(self, batch): x = np.empty((self.batch_size, *self.dim, self.n_channels)) y = np.empty((self.batch_size, *self.dim, 1)) for i, batch_id in enumerate(batch): x[i,], y[i,] = self.load( self.data[\"image\"][batch_id], self.data[\"depth\"][batch_id], self.data[\"mask\"][batch_id], ) return x, y Visualizing samples def visualize_depth_map(samples, test=False, model=None): input, target = samples cmap = plt.cm.jet cmap.set_bad(color=\"black\") if test: pred = model.predict(input) fig, ax = plt.subplots(6, 3, figsize=(50, 50)) for i in range(6): ax[i, 0].imshow((input[i].squeeze())) ax[i, 1].imshow((target[i].squeeze()), cmap=cmap) ax[i, 2].imshow((pred[i].squeeze()), cmap=cmap) else: fig, ax = plt.subplots(6, 2, figsize=(50, 50)) for i in range(6): ax[i, 0].imshow((input[i].squeeze())) ax[i, 1].imshow((target[i].squeeze()), cmap=cmap) visualize_samples = next( iter(DataGenerator(data=df, batch_size=6, dim=(HEIGHT, WIDTH))) ) visualize_depth_map(visualize_samples) png 3D point cloud visualization depth_vis = np.flipud(visualize_samples[1][1].squeeze()) # target img_vis = np.flipud(visualize_samples[0][1].squeeze()) # input fig = plt.figure(figsize=(15, 10)) ax = plt.axes(projection=\"3d\") STEP = 3 for x in range(0, img_vis.shape[0], STEP): for y in range(0, img_vis.shape[1], STEP): ax.scatter( [depth_vis[x, y]] * 3, [y] * 3, [x] * 3, c=tuple(img_vis[x, y, :3] / 255), s=3, ) ax.view_init(45, 135) png Building the model The basic model is from U-Net. Addditive skip-connections are implemented in the downscaling block. class DownscaleBlock(layers.Layer): def __init__( self, filters, kernel_size=(3, 3), padding=\"same\", strides=1, **kwargs ): super().__init__(**kwargs) self.convA = layers.Conv2D(filters, kernel_size, strides, padding) self.convB = layers.Conv2D(filters, kernel_size, strides, padding) self.reluA = layers.LeakyReLU(alpha=0.2) self.reluB = layers.LeakyReLU(alpha=0.2) self.bn2a = tf.keras.layers.BatchNormalization() self.bn2b = tf.keras.layers.BatchNormalization() self.pool = layers.MaxPool2D((2, 2), (2, 2)) def call(self, input_tensor): d = self.convA(input_tensor) x = self.bn2a(d) x = self.reluA(x) x = self.convB(x) x = self.bn2b(x) x = self.reluB(x) x += d p = self.pool(x) return x, p class UpscaleBlock(layers.Layer): def __init__( self, filters, kernel_size=(3, 3), padding=\"same\", strides=1, **kwargs ): super().__init__(**kwargs) self.us = layers.UpSampling2D((2, 2)) self.convA = layers.Conv2D(filters, kernel_size, strides, padding) self.convB = layers.Conv2D(filters, kernel_size, strides, padding) self.reluA = layers.LeakyReLU(alpha=0.2) self.reluB = layers.LeakyReLU(alpha=0.2) self.bn2a = tf.keras.layers.BatchNormalization() self.bn2b = tf.keras.layers.BatchNormalization() self.conc = layers.Concatenate() def call(self, x, skip): x = self.us(x) concat = self.conc([x, skip]) x = self.convA(concat) x = self.bn2a(x) x = self.reluA(x) x = self.convB(x) x = self.bn2b(x) x = self.reluB(x) return x class BottleNeckBlock(layers.Layer): def __init__( self, filters, kernel_size=(3, 3), padding=\"same\", strides=1, **kwargs ): super().__init__(**kwargs) self.convA = layers.Conv2D(filters, kernel_size, strides, padding) self.convB = layers.Conv2D(filters, kernel_size, strides, padding) self.reluA = layers.LeakyReLU(alpha=0.2) self.reluB = layers.LeakyReLU(alpha=0.2) def call(self, x): x = self.convA(x) x = self.reluA(x) x = self.convB(x) x = self.reluB(x) return x Defining the loss We will optimize 3 losses in our mode. 1. Structural similarity index(SSIM). 2. L1-loss, or Point-wise depth in our case. 3. Depth smoothness loss. Out of the three loss functions, SSIM contributes the most to improving model performance. class DepthEstimationModel(tf.keras.Model): def __init__(self): super().__init__() self.ssim_loss_weight = 0.85 self.l1_loss_weight = 0.1 self.edge_loss_weight = 0.9 self.loss_metric = tf.keras.metrics.Mean(name=\"loss\") f = [16, 32, 64, 128, 256] self.downscale_blocks = [ DownscaleBlock(f[0]), DownscaleBlock(f[1]), DownscaleBlock(f[2]), DownscaleBlock(f[3]), ] self.bottle_neck_block = BottleNeckBlock(f[4]) self.upscale_blocks = [ UpscaleBlock(f[3]), UpscaleBlock(f[2]), UpscaleBlock(f[1]), UpscaleBlock(f[0]), ] self.conv_layer = layers.Conv2D(1, (1, 1), padding=\"same\", activation=\"tanh\") def calculate_loss(self, target, pred): # Edges dy_true, dx_true = tf.image.image_gradients(target) dy_pred, dx_pred = tf.image.image_gradients(pred) weights_x = tf.exp(tf.reduce_mean(tf.abs(dx_true))) weights_y = tf.exp(tf.reduce_mean(tf.abs(dy_true))) # Depth smoothness smoothness_x = dx_pred * weights_x smoothness_y = dy_pred * weights_y depth_smoothness_loss = tf.reduce_mean(abs(smoothness_x)) + tf.reduce_mean( abs(smoothness_y) ) # Structural similarity (SSIM) index ssim_loss = tf.reduce_mean( 1 - tf.image.ssim( target, pred, max_val=WIDTH, filter_size=7, k1=0.01 ** 2, k2=0.03 ** 2 ) ) # Point-wise depth l1_loss = tf.reduce_mean(tf.abs(target - pred)) loss = ( (self.ssim_loss_weight * ssim_loss) + (self.l1_loss_weight * l1_loss) + (self.edge_loss_weight * depth_smoothness_loss) ) return loss @property def metrics(self): return [self.loss_metric] def train_step(self, batch_data): input, target = batch_data with tf.GradientTape() as tape: pred = self(input, training=True) loss = self.calculate_loss(target, pred) gradients = tape.gradient(loss, self.trainable_variables) self.optimizer.apply_gradients(zip(gradients, self.trainable_variables)) self.loss_metric.update_state(loss) return { \"loss\": self.loss_metric.result(), } def test_step(self, batch_data): input, target = batch_data pred = self(input, training=False) loss = self.calculate_loss(target, pred) self.loss_metric.update_state(loss) return { \"loss\": self.loss_metric.result(), } def call(self, x): c1, p1 = self.downscale_blocks[0](x) c2, p2 = self.downscale_blocks[1](p1) c3, p3 = self.downscale_blocks[2](p2) c4, p4 = self.downscale_blocks[3](p3) bn = self.bottle_neck_block(p4) u1 = self.upscale_blocks[0](bn, c4) u2 = self.upscale_blocks[1](u1, c3) u3 = self.upscale_blocks[2](u2, c2) u4 = self.upscale_blocks[3](u3, c1) return self.conv_layer(u4) Model training optimizer = tf.keras.optimizers.Adam( learning_rate=LR, amsgrad=False, ) model = DepthEstimationModel() # Define the loss function cross_entropy = tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True, reduction=\"none\" ) # Compile the model model.compile(optimizer, loss=cross_entropy) train_loader = DataGenerator( data=df[:260].reset_index(drop=\"true\"), batch_size=BATCH_SIZE, dim=(HEIGHT, WIDTH) ) validation_loader = DataGenerator( data=df[260:].reset_index(drop=\"true\"), batch_size=BATCH_SIZE, dim=(HEIGHT, WIDTH) ) model.fit( train_loader, epochs=EPOCHS, validation_data=validation_loader, ) Epoch 1/30 9/9 [==============================] - 18s 1s/step - loss: 1.1543 - val_loss: 1.4281 Epoch 2/30 9/9 [==============================] - 3s 390ms/step - loss: 0.8727 - val_loss: 1.0686 Epoch 3/30 9/9 [==============================] - 4s 428ms/step - loss: 0.6659 - val_loss: 0.7884 Epoch 4/30 9/9 [==============================] - 3s 334ms/step - loss: 0.6462 - val_loss: 0.6198 Epoch 5/30 9/9 [==============================] - 3s 355ms/step - loss: 0.5689 - val_loss: 0.6207 Epoch 6/30 9/9 [==============================] - 3s 361ms/step - loss: 0.5067 - val_loss: 0.4876 Epoch 7/30 9/9 [==============================] - 3s 357ms/step - loss: 0.4680 - val_loss: 0.4698 Epoch 8/30 9/9 [==============================] - 3s 325ms/step - loss: 0.4622 - val_loss: 0.7249 Epoch 9/30 9/9 [==============================] - 3s 393ms/step - loss: 0.4215 - val_loss: 0.3826 Epoch 10/30 9/9 [==============================] - 3s 337ms/step - loss: 0.3788 - val_loss: 0.3289 Epoch 11/30 9/9 [==============================] - 3s 345ms/step - loss: 0.3347 - val_loss: 0.3032 Epoch 12/30 9/9 [==============================] - 3s 327ms/step - loss: 0.3488 - val_loss: 0.2631 Epoch 13/30 9/9 [==============================] - 3s 326ms/step - loss: 0.3315 - val_loss: 0.2383 Epoch 14/30 9/9 [==============================] - 3s 331ms/step - loss: 0.3349 - val_loss: 0.2379 Epoch 15/30 9/9 [==============================] - 3s 333ms/step - loss: 0.3394 - val_loss: 0.2151 Epoch 16/30 9/9 [==============================] - 3s 337ms/step - loss: 0.3073 - val_loss: 0.2243 Epoch 17/30 9/9 [==============================] - 3s 355ms/step - loss: 0.3951 - val_loss: 0.2627 Epoch 18/30 9/9 [==============================] - 3s 335ms/step - loss: 0.3657 - val_loss: 0.2175 Epoch 19/30 9/9 [==============================] - 3s 321ms/step - loss: 0.3404 - val_loss: 0.2073 Epoch 20/30 9/9 [==============================] - 3s 320ms/step - loss: 0.3549 - val_loss: 0.1972 Epoch 21/30 9/9 [==============================] - 3s 317ms/step - loss: 0.2802 - val_loss: 0.1936 Epoch 22/30 9/9 [==============================] - 3s 316ms/step - loss: 0.2632 - val_loss: 0.1893 Epoch 23/30 9/9 [==============================] - 3s 318ms/step - loss: 0.2862 - val_loss: 0.1807 Epoch 24/30 9/9 [==============================] - 3s 328ms/step - loss: 0.3083 - val_loss: 0.1923 Epoch 25/30 9/9 [==============================] - 3s 312ms/step - loss: 0.3666 - val_loss: 0.1795 Epoch 26/30 9/9 [==============================] - 3s 316ms/step - loss: 0.2928 - val_loss: 0.1753 Epoch 27/30 9/9 [==============================] - 3s 325ms/step - loss: 0.2945 - val_loss: 0.1790 Epoch 28/30 9/9 [==============================] - 3s 325ms/step - loss: 0.2642 - val_loss: 0.1775 Epoch 29/30 9/9 [==============================] - 3s 333ms/step - loss: 0.2546 - val_loss: 0.1810 Epoch 30/30 9/9 [==============================] - 3s 315ms/step - loss: 0.2650 - val_loss: 0.1795 Visualizing model output We visualize the model output over the validation set. The first image is the RGB image, the second image is the ground truth depth map image and the third one is the predicted depth map image. test_loader = next( iter( DataGenerator( data=df[265:].reset_index(drop=\"true\"), batch_size=6, dim=(HEIGHT, WIDTH) ) ) ) visualize_depth_map(test_loader, test=True, model=model) test_loader = next( iter( DataGenerator( data=df[300:].reset_index(drop=\"true\"), batch_size=6, dim=(HEIGHT, WIDTH) ) ) ) visualize_depth_map(test_loader, test=True, model=model) png png Possible improvements You can improve this model by replacing the encoding part of the U-Net with a pretrained DenseNet or ResNet. Loss functions play an important role in solving this problem. Tuning the loss functions may yield significant improvement. References The following papers go deeper into possible approaches for depth estimation. 1. Depth Prediction Without the Sensors: Leveraging Structure for Unsupervised Learning from Monocular Videos 2. Digging Into Self-Supervised Monocular Depth Estimation 3. Deeper Depth Prediction with Fully Convolutional Residual Networks You can also find helpful implementations in the papers with code depth estimation task. Implement DeepLabV3+ architecture for Multi-class Semantic Segmentation. Introduction Semantic segmentation, with the goal to assign semantic labels to every pixel in an image, is an essential computer vision task. In this example, we implement the DeepLabV3+ model for multi-class semantic segmentation, a fully-convolutional architecture that performs well on semantic segmentation benchmarks. References: Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation Rethinking Atrous Convolution for Semantic Image Segmentation DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs Downloading the data We will use the Crowd Instance-level Human Parsing Dataset for training our model. The Crowd Instance-level Human Parsing (CIHP) dataset has 38,280 diverse human images. Each image in CIHP is labeled with pixel-wise annotations for 20 categories, as well as instance-level identification. This dataset can be used for the \"human part segmentation\" task. import os import cv2 import numpy as np from glob import glob from scipy.io import loadmat import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers !gdown https://drive.google.com/uc?id=1B9A9UCJYMwTL4oBEo4RZfbMZMaZhKJaz !unzip -q instance-level-human-parsing.zip Downloading... From: https://drive.google.com/uc?id=1B9A9UCJYMwTL4oBEo4RZfbMZMaZhKJaz To: /content/keras-io/scripts/tmp_4374681/instance-level-human-parsing.zip 2.91GB [00:36, 79.6MB/s] Creating a TensorFlow Dataset Training on the entire CIHP dataset with 38,280 images takes a lot of time, hence we will be using a smaller subset of 200 images for training our model in this example. IMAGE_SIZE = 512 BATCH_SIZE = 4 NUM_CLASSES = 20 DATA_DIR = \"./instance-level_human_parsing/instance-level_human_parsing/Training\" NUM_TRAIN_IMAGES = 1000 NUM_VAL_IMAGES = 50 train_images = sorted(glob(os.path.join(DATA_DIR, \"Images/*\")))[:NUM_TRAIN_IMAGES] train_masks = sorted(glob(os.path.join(DATA_DIR, \"Category_ids/*\")))[:NUM_TRAIN_IMAGES] val_images = sorted(glob(os.path.join(DATA_DIR, \"Images/*\")))[ NUM_TRAIN_IMAGES : NUM_VAL_IMAGES + NUM_TRAIN_IMAGES ] val_masks = sorted(glob(os.path.join(DATA_DIR, \"Category_ids/*\")))[ NUM_TRAIN_IMAGES : NUM_VAL_IMAGES + NUM_TRAIN_IMAGES ] def read_image(image_path, mask=False): image = tf.io.read_file(image_path) if mask: image = tf.image.decode_png(image, channels=1) image.set_shape([None, None, 1]) image = tf.image.resize(images=image, size=[IMAGE_SIZE, IMAGE_SIZE]) else: image = tf.image.decode_png(image, channels=3) image.set_shape([None, None, 3]) image = tf.image.resize(images=image, size=[IMAGE_SIZE, IMAGE_SIZE]) image = image / 127.5 - 1 return image def load_data(image_list, mask_list): image = read_image(image_list) mask = read_image(mask_list, mask=True) return image, mask def data_generator(image_list, mask_list): dataset = tf.data.Dataset.from_tensor_slices((image_list, mask_list)) dataset = dataset.map(load_data, num_parallel_calls=tf.data.AUTOTUNE) dataset = dataset.batch(BATCH_SIZE, drop_remainder=True) return dataset train_dataset = data_generator(train_images, train_masks) val_dataset = data_generator(val_images, val_masks) print(\"Train Dataset:\", train_dataset) print(\"Val Dataset:\", val_dataset) Train Dataset: Val Dataset: Building the DeepLabV3+ model DeepLabv3+ extends DeepLabv3 by adding an encoder-decoder structure. The encoder module processes multiscale contextual information by applying dilated convolution at multiple scales, while the decoder module refines the segmentation results along object boundaries. Dilated convolution: With dilated convolution, as we go deeper in the network, we can keep the stride constant but with larger field-of-view without increasing the number of parameters or the amount of computation. Besides, it enables larger output feature maps, which is useful for semantic segmentation. The reason for using Dilated Spatial Pyramid Pooling is that it was shown that as the sampling rate becomes larger, the number of valid filter weights (i.e., weights that are applied to the valid feature region, instead of padded zeros) becomes smaller. def convolution_block( block_input, num_filters=256, kernel_size=3, dilation_rate=1, padding=\"same\", use_bias=False, ): x = layers.Conv2D( num_filters, kernel_size=kernel_size, dilation_rate=dilation_rate, padding=\"same\", use_bias=use_bias, kernel_initializer=keras.initializers.HeNormal(), )(block_input) x = layers.BatchNormalization()(x) return tf.nn.relu(x) def DilatedSpatialPyramidPooling(dspp_input): dims = dspp_input.shape x = layers.AveragePooling2D(pool_size=(dims[-3], dims[-2]))(dspp_input) x = convolution_block(x, kernel_size=1, use_bias=True) out_pool = layers.UpSampling2D( size=(dims[-3] // x.shape[1], dims[-2] // x.shape[2]), interpolation=\"bilinear\", )(x) out_1 = convolution_block(dspp_input, kernel_size=1, dilation_rate=1) out_6 = convolution_block(dspp_input, kernel_size=3, dilation_rate=6) out_12 = convolution_block(dspp_input, kernel_size=3, dilation_rate=12) out_18 = convolution_block(dspp_input, kernel_size=3, dilation_rate=18) x = layers.Concatenate(axis=-1)([out_pool, out_1, out_6, out_12, out_18]) output = convolution_block(x, kernel_size=1) return output The encoder features are first bilinearly upsampled by a factor 4, and then concatenated with the corresponding low-level features from the network backbone that have the same spatial resolution. For this example, we use a ResNet50 pretrained on ImageNet as the backbone model, and we use the low-level features from the conv4_block6_2_relu block of the backbone. def DeeplabV3Plus(image_size, num_classes): model_input = keras.Input(shape=(image_size, image_size, 3)) resnet50 = keras.applications.ResNet50( weights=\"imagenet\", include_top=False, input_tensor=model_input ) x = resnet50.get_layer(\"conv4_block6_2_relu\").output x = DilatedSpatialPyramidPooling(x) input_a = layers.UpSampling2D( size=(image_size // 4 // x.shape[1], image_size // 4 // x.shape[2]), interpolation=\"bilinear\", )(x) input_b = resnet50.get_layer(\"conv2_block3_2_relu\").output input_b = convolution_block(input_b, num_filters=48, kernel_size=1) x = layers.Concatenate(axis=-1)([input_a, input_b]) x = convolution_block(x) x = convolution_block(x) x = layers.UpSampling2D( size=(image_size // x.shape[1], image_size // x.shape[2]), interpolation=\"bilinear\", )(x) model_output = layers.Conv2D(num_classes, kernel_size=(1, 1), padding=\"same\")(x) return keras.Model(inputs=model_input, outputs=model_output) model = DeeplabV3Plus(image_size=IMAGE_SIZE, num_classes=NUM_CLASSES) model.summary() Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5 94773248/94765736 [==============================] - 1s 0us/step 94781440/94765736 [==============================] - 1s 0us/step Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 512, 512, 3) 0 __________________________________________________________________________________________________ conv1_pad (ZeroPadding2D) (None, 518, 518, 3) 0 input_1[0][0] __________________________________________________________________________________________________ conv1_conv (Conv2D) (None, 256, 256, 64) 9472 conv1_pad[0][0] __________________________________________________________________________________________________ conv1_bn (BatchNormalization) (None, 256, 256, 64) 256 conv1_conv[0][0] __________________________________________________________________________________________________ conv1_relu (Activation) (None, 256, 256, 64) 0 conv1_bn[0][0] __________________________________________________________________________________________________ pool1_pad (ZeroPadding2D) (None, 258, 258, 64) 0 conv1_relu[0][0] __________________________________________________________________________________________________ pool1_pool (MaxPooling2D) (None, 128, 128, 64) 0 pool1_pad[0][0] __________________________________________________________________________________________________ conv2_block1_1_conv (Conv2D) (None, 128, 128, 64) 4160 pool1_pool[0][0] __________________________________________________________________________________________________ conv2_block1_1_bn (BatchNormali (None, 128, 128, 64) 256 conv2_block1_1_conv[0][0] __________________________________________________________________________________________________ conv2_block1_1_relu (Activation (None, 128, 128, 64) 0 conv2_block1_1_bn[0][0] __________________________________________________________________________________________________ conv2_block1_2_conv (Conv2D) (None, 128, 128, 64) 36928 conv2_block1_1_relu[0][0] __________________________________________________________________________________________________ conv2_block1_2_bn (BatchNormali (None, 128, 128, 64) 256 conv2_block1_2_conv[0][0] __________________________________________________________________________________________________ conv2_block1_2_relu (Activation (None, 128, 128, 64) 0 conv2_block1_2_bn[0][0] __________________________________________________________________________________________________ conv2_block1_0_conv (Conv2D) (None, 128, 128, 256 16640 pool1_pool[0][0] __________________________________________________________________________________________________ conv2_block1_3_conv (Conv2D) (None, 128, 128, 256 16640 conv2_block1_2_relu[0][0] __________________________________________________________________________________________________ conv2_block1_0_bn (BatchNormali (None, 128, 128, 256 1024 conv2_block1_0_conv[0][0] __________________________________________________________________________________________________ conv2_block1_3_bn (BatchNormali (None, 128, 128, 256 1024 conv2_block1_3_conv[0][0] __________________________________________________________________________________________________ conv2_block1_add (Add) (None, 128, 128, 256 0 conv2_block1_0_bn[0][0] conv2_block1_3_bn[0][0] __________________________________________________________________________________________________ conv2_block1_out (Activation) (None, 128, 128, 256 0 conv2_block1_add[0][0] __________________________________________________________________________________________________ conv2_block2_1_conv (Conv2D) (None, 128, 128, 64) 16448 conv2_block1_out[0][0] __________________________________________________________________________________________________ conv2_block2_1_bn (BatchNormali (None, 128, 128, 64) 256 conv2_block2_1_conv[0][0] __________________________________________________________________________________________________ conv2_block2_1_relu (Activation (None, 128, 128, 64) 0 conv2_block2_1_bn[0][0] __________________________________________________________________________________________________ conv2_block2_2_conv (Conv2D) (None, 128, 128, 64) 36928 conv2_block2_1_relu[0][0] __________________________________________________________________________________________________ conv2_block2_2_bn (BatchNormali (None, 128, 128, 64) 256 conv2_block2_2_conv[0][0] __________________________________________________________________________________________________ conv2_block2_2_relu (Activation (None, 128, 128, 64) 0 conv2_block2_2_bn[0][0] __________________________________________________________________________________________________ conv2_block2_3_conv (Conv2D) (None, 128, 128, 256 16640 conv2_block2_2_relu[0][0] __________________________________________________________________________________________________ conv2_block2_3_bn (BatchNormali (None, 128, 128, 256 1024 conv2_block2_3_conv[0][0] __________________________________________________________________________________________________ conv2_block2_add (Add) (None, 128, 128, 256 0 conv2_block1_out[0][0] conv2_block2_3_bn[0][0] __________________________________________________________________________________________________ conv2_block2_out (Activation) (None, 128, 128, 256 0 conv2_block2_add[0][0] __________________________________________________________________________________________________ conv2_block3_1_conv (Conv2D) (None, 128, 128, 64) 16448 conv2_block2_out[0][0] __________________________________________________________________________________________________ conv2_block3_1_bn (BatchNormali (None, 128, 128, 64) 256 conv2_block3_1_conv[0][0] __________________________________________________________________________________________________ conv2_block3_1_relu (Activation (None, 128, 128, 64) 0 conv2_block3_1_bn[0][0] __________________________________________________________________________________________________ conv2_block3_2_conv (Conv2D) (None, 128, 128, 64) 36928 conv2_block3_1_relu[0][0] __________________________________________________________________________________________________ conv2_block3_2_bn (BatchNormali (None, 128, 128, 64) 256 conv2_block3_2_conv[0][0] __________________________________________________________________________________________________ conv2_block3_2_relu (Activation (None, 128, 128, 64) 0 conv2_block3_2_bn[0][0] __________________________________________________________________________________________________ conv2_block3_3_conv (Conv2D) (None, 128, 128, 256 16640 conv2_block3_2_relu[0][0] __________________________________________________________________________________________________ conv2_block3_3_bn (BatchNormali (None, 128, 128, 256 1024 conv2_block3_3_conv[0][0] __________________________________________________________________________________________________ conv2_block3_add (Add) (None, 128, 128, 256 0 conv2_block2_out[0][0] conv2_block3_3_bn[0][0] __________________________________________________________________________________________________ conv2_block3_out (Activation) (None, 128, 128, 256 0 conv2_block3_add[0][0] __________________________________________________________________________________________________ conv3_block1_1_conv (Conv2D) (None, 64, 64, 128) 32896 conv2_block3_out[0][0] __________________________________________________________________________________________________ conv3_block1_1_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block1_1_conv[0][0] __________________________________________________________________________________________________ conv3_block1_1_relu (Activation (None, 64, 64, 128) 0 conv3_block1_1_bn[0][0] __________________________________________________________________________________________________ conv3_block1_2_conv (Conv2D) (None, 64, 64, 128) 147584 conv3_block1_1_relu[0][0] __________________________________________________________________________________________________ conv3_block1_2_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block1_2_conv[0][0] __________________________________________________________________________________________________ conv3_block1_2_relu (Activation (None, 64, 64, 128) 0 conv3_block1_2_bn[0][0] __________________________________________________________________________________________________ conv3_block1_0_conv (Conv2D) (None, 64, 64, 512) 131584 conv2_block3_out[0][0] __________________________________________________________________________________________________ conv3_block1_3_conv (Conv2D) (None, 64, 64, 512) 66048 conv3_block1_2_relu[0][0] __________________________________________________________________________________________________ conv3_block1_0_bn (BatchNormali (None, 64, 64, 512) 2048 conv3_block1_0_conv[0][0] __________________________________________________________________________________________________ conv3_block1_3_bn (BatchNormali (None, 64, 64, 512) 2048 conv3_block1_3_conv[0][0] __________________________________________________________________________________________________ conv3_block1_add (Add) (None, 64, 64, 512) 0 conv3_block1_0_bn[0][0] conv3_block1_3_bn[0][0] __________________________________________________________________________________________________ conv3_block1_out (Activation) (None, 64, 64, 512) 0 conv3_block1_add[0][0] __________________________________________________________________________________________________ conv3_block2_1_conv (Conv2D) (None, 64, 64, 128) 65664 conv3_block1_out[0][0] __________________________________________________________________________________________________ conv3_block2_1_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block2_1_conv[0][0] __________________________________________________________________________________________________ conv3_block2_1_relu (Activation (None, 64, 64, 128) 0 conv3_block2_1_bn[0][0] __________________________________________________________________________________________________ conv3_block2_2_conv (Conv2D) (None, 64, 64, 128) 147584 conv3_block2_1_relu[0][0] __________________________________________________________________________________________________ conv3_block2_2_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block2_2_conv[0][0] __________________________________________________________________________________________________ conv3_block2_2_relu (Activation (None, 64, 64, 128) 0 conv3_block2_2_bn[0][0] __________________________________________________________________________________________________ conv3_block2_3_conv (Conv2D) (None, 64, 64, 512) 66048 conv3_block2_2_relu[0][0] __________________________________________________________________________________________________ conv3_block2_3_bn (BatchNormali (None, 64, 64, 512) 2048 conv3_block2_3_conv[0][0] __________________________________________________________________________________________________ conv3_block2_add (Add) (None, 64, 64, 512) 0 conv3_block1_out[0][0] conv3_block2_3_bn[0][0] __________________________________________________________________________________________________ conv3_block2_out (Activation) (None, 64, 64, 512) 0 conv3_block2_add[0][0] __________________________________________________________________________________________________ conv3_block3_1_conv (Conv2D) (None, 64, 64, 128) 65664 conv3_block2_out[0][0] __________________________________________________________________________________________________ conv3_block3_1_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block3_1_conv[0][0] __________________________________________________________________________________________________ conv3_block3_1_relu (Activation (None, 64, 64, 128) 0 conv3_block3_1_bn[0][0] __________________________________________________________________________________________________ conv3_block3_2_conv (Conv2D) (None, 64, 64, 128) 147584 conv3_block3_1_relu[0][0] __________________________________________________________________________________________________ conv3_block3_2_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block3_2_conv[0][0] __________________________________________________________________________________________________ conv3_block3_2_relu (Activation (None, 64, 64, 128) 0 conv3_block3_2_bn[0][0] __________________________________________________________________________________________________ conv3_block3_3_conv (Conv2D) (None, 64, 64, 512) 66048 conv3_block3_2_relu[0][0] __________________________________________________________________________________________________ conv3_block3_3_bn (BatchNormali (None, 64, 64, 512) 2048 conv3_block3_3_conv[0][0] __________________________________________________________________________________________________ conv3_block3_add (Add) (None, 64, 64, 512) 0 conv3_block2_out[0][0] conv3_block3_3_bn[0][0] __________________________________________________________________________________________________ conv3_block3_out (Activation) (None, 64, 64, 512) 0 conv3_block3_add[0][0] __________________________________________________________________________________________________ conv3_block4_1_conv (Conv2D) (None, 64, 64, 128) 65664 conv3_block3_out[0][0] __________________________________________________________________________________________________ conv3_block4_1_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block4_1_conv[0][0] __________________________________________________________________________________________________ conv3_block4_1_relu (Activation (None, 64, 64, 128) 0 conv3_block4_1_bn[0][0] __________________________________________________________________________________________________ conv3_block4_2_conv (Conv2D) (None, 64, 64, 128) 147584 conv3_block4_1_relu[0][0] __________________________________________________________________________________________________ conv3_block4_2_bn (BatchNormali (None, 64, 64, 128) 512 conv3_block4_2_conv[0][0] __________________________________________________________________________________________________ conv3_block4_2_relu (Activation (None, 64, 64, 128) 0 conv3_block4_2_bn[0][0] __________________________________________________________________________________________________ conv3_block4_3_conv (Conv2D) (None, 64, 64, 512) 66048 conv3_block4_2_relu[0][0] __________________________________________________________________________________________________ conv3_block4_3_bn (BatchNormali (None, 64, 64, 512) 2048 conv3_block4_3_conv[0][0] __________________________________________________________________________________________________ conv3_block4_add (Add) (None, 64, 64, 512) 0 conv3_block3_out[0][0] conv3_block4_3_bn[0][0] __________________________________________________________________________________________________ conv3_block4_out (Activation) (None, 64, 64, 512) 0 conv3_block4_add[0][0] __________________________________________________________________________________________________ conv4_block1_1_conv (Conv2D) (None, 32, 32, 256) 131328 conv3_block4_out[0][0] __________________________________________________________________________________________________ conv4_block1_1_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block1_1_conv[0][0] __________________________________________________________________________________________________ conv4_block1_1_relu (Activation (None, 32, 32, 256) 0 conv4_block1_1_bn[0][0] __________________________________________________________________________________________________ conv4_block1_2_conv (Conv2D) (None, 32, 32, 256) 590080 conv4_block1_1_relu[0][0] __________________________________________________________________________________________________ conv4_block1_2_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block1_2_conv[0][0] __________________________________________________________________________________________________ conv4_block1_2_relu (Activation (None, 32, 32, 256) 0 conv4_block1_2_bn[0][0] __________________________________________________________________________________________________ conv4_block1_0_conv (Conv2D) (None, 32, 32, 1024) 525312 conv3_block4_out[0][0] __________________________________________________________________________________________________ conv4_block1_3_conv (Conv2D) (None, 32, 32, 1024) 263168 conv4_block1_2_relu[0][0] __________________________________________________________________________________________________ conv4_block1_0_bn (BatchNormali (None, 32, 32, 1024) 4096 conv4_block1_0_conv[0][0] __________________________________________________________________________________________________ conv4_block1_3_bn (BatchNormali (None, 32, 32, 1024) 4096 conv4_block1_3_conv[0][0] __________________________________________________________________________________________________ conv4_block1_add (Add) (None, 32, 32, 1024) 0 conv4_block1_0_bn[0][0] conv4_block1_3_bn[0][0] __________________________________________________________________________________________________ conv4_block1_out (Activation) (None, 32, 32, 1024) 0 conv4_block1_add[0][0] __________________________________________________________________________________________________ conv4_block2_1_conv (Conv2D) (None, 32, 32, 256) 262400 conv4_block1_out[0][0] __________________________________________________________________________________________________ conv4_block2_1_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block2_1_conv[0][0] __________________________________________________________________________________________________ conv4_block2_1_relu (Activation (None, 32, 32, 256) 0 conv4_block2_1_bn[0][0] __________________________________________________________________________________________________ conv4_block2_2_conv (Conv2D) (None, 32, 32, 256) 590080 conv4_block2_1_relu[0][0] __________________________________________________________________________________________________ conv4_block2_2_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block2_2_conv[0][0] __________________________________________________________________________________________________ conv4_block2_2_relu (Activation (None, 32, 32, 256) 0 conv4_block2_2_bn[0][0] __________________________________________________________________________________________________ conv4_block2_3_conv (Conv2D) (None, 32, 32, 1024) 263168 conv4_block2_2_relu[0][0] __________________________________________________________________________________________________ conv4_block2_3_bn (BatchNormali (None, 32, 32, 1024) 4096 conv4_block2_3_conv[0][0] __________________________________________________________________________________________________ conv4_block2_add (Add) (None, 32, 32, 1024) 0 conv4_block1_out[0][0] conv4_block2_3_bn[0][0] __________________________________________________________________________________________________ conv4_block2_out (Activation) (None, 32, 32, 1024) 0 conv4_block2_add[0][0] __________________________________________________________________________________________________ conv4_block3_1_conv (Conv2D) (None, 32, 32, 256) 262400 conv4_block2_out[0][0] __________________________________________________________________________________________________ conv4_block3_1_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block3_1_conv[0][0] __________________________________________________________________________________________________ conv4_block3_1_relu (Activation (None, 32, 32, 256) 0 conv4_block3_1_bn[0][0] __________________________________________________________________________________________________ conv4_block3_2_conv (Conv2D) (None, 32, 32, 256) 590080 conv4_block3_1_relu[0][0] __________________________________________________________________________________________________ conv4_block3_2_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block3_2_conv[0][0] __________________________________________________________________________________________________ conv4_block3_2_relu (Activation (None, 32, 32, 256) 0 conv4_block3_2_bn[0][0] __________________________________________________________________________________________________ conv4_block3_3_conv (Conv2D) (None, 32, 32, 1024) 263168 conv4_block3_2_relu[0][0] __________________________________________________________________________________________________ conv4_block3_3_bn (BatchNormali (None, 32, 32, 1024) 4096 conv4_block3_3_conv[0][0] __________________________________________________________________________________________________ conv4_block3_add (Add) (None, 32, 32, 1024) 0 conv4_block2_out[0][0] conv4_block3_3_bn[0][0] __________________________________________________________________________________________________ conv4_block3_out (Activation) (None, 32, 32, 1024) 0 conv4_block3_add[0][0] __________________________________________________________________________________________________ conv4_block4_1_conv (Conv2D) (None, 32, 32, 256) 262400 conv4_block3_out[0][0] __________________________________________________________________________________________________ conv4_block4_1_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block4_1_conv[0][0] __________________________________________________________________________________________________ conv4_block4_1_relu (Activation (None, 32, 32, 256) 0 conv4_block4_1_bn[0][0] __________________________________________________________________________________________________ conv4_block4_2_conv (Conv2D) (None, 32, 32, 256) 590080 conv4_block4_1_relu[0][0] __________________________________________________________________________________________________ conv4_block4_2_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block4_2_conv[0][0] __________________________________________________________________________________________________ conv4_block4_2_relu (Activation (None, 32, 32, 256) 0 conv4_block4_2_bn[0][0] __________________________________________________________________________________________________ conv4_block4_3_conv (Conv2D) (None, 32, 32, 1024) 263168 conv4_block4_2_relu[0][0] __________________________________________________________________________________________________ conv4_block4_3_bn (BatchNormali (None, 32, 32, 1024) 4096 conv4_block4_3_conv[0][0] __________________________________________________________________________________________________ conv4_block4_add (Add) (None, 32, 32, 1024) 0 conv4_block3_out[0][0] conv4_block4_3_bn[0][0] __________________________________________________________________________________________________ conv4_block4_out (Activation) (None, 32, 32, 1024) 0 conv4_block4_add[0][0] __________________________________________________________________________________________________ conv4_block5_1_conv (Conv2D) (None, 32, 32, 256) 262400 conv4_block4_out[0][0] __________________________________________________________________________________________________ conv4_block5_1_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block5_1_conv[0][0] __________________________________________________________________________________________________ conv4_block5_1_relu (Activation (None, 32, 32, 256) 0 conv4_block5_1_bn[0][0] __________________________________________________________________________________________________ conv4_block5_2_conv (Conv2D) (None, 32, 32, 256) 590080 conv4_block5_1_relu[0][0] __________________________________________________________________________________________________ conv4_block5_2_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block5_2_conv[0][0] __________________________________________________________________________________________________ conv4_block5_2_relu (Activation (None, 32, 32, 256) 0 conv4_block5_2_bn[0][0] __________________________________________________________________________________________________ conv4_block5_3_conv (Conv2D) (None, 32, 32, 1024) 263168 conv4_block5_2_relu[0][0] __________________________________________________________________________________________________ conv4_block5_3_bn (BatchNormali (None, 32, 32, 1024) 4096 conv4_block5_3_conv[0][0] __________________________________________________________________________________________________ conv4_block5_add (Add) (None, 32, 32, 1024) 0 conv4_block4_out[0][0] conv4_block5_3_bn[0][0] __________________________________________________________________________________________________ conv4_block5_out (Activation) (None, 32, 32, 1024) 0 conv4_block5_add[0][0] __________________________________________________________________________________________________ conv4_block6_1_conv (Conv2D) (None, 32, 32, 256) 262400 conv4_block5_out[0][0] __________________________________________________________________________________________________ conv4_block6_1_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block6_1_conv[0][0] __________________________________________________________________________________________________ conv4_block6_1_relu (Activation (None, 32, 32, 256) 0 conv4_block6_1_bn[0][0] __________________________________________________________________________________________________ conv4_block6_2_conv (Conv2D) (None, 32, 32, 256) 590080 conv4_block6_1_relu[0][0] __________________________________________________________________________________________________ conv4_block6_2_bn (BatchNormali (None, 32, 32, 256) 1024 conv4_block6_2_conv[0][0] __________________________________________________________________________________________________ conv4_block6_2_relu (Activation (None, 32, 32, 256) 0 conv4_block6_2_bn[0][0] __________________________________________________________________________________________________ average_pooling2d (AveragePooli (None, 1, 1, 256) 0 conv4_block6_2_relu[0][0] __________________________________________________________________________________________________ conv2d (Conv2D) (None, 1, 1, 256) 65792 average_pooling2d[0][0] __________________________________________________________________________________________________ batch_normalization (BatchNorma (None, 1, 1, 256) 1024 conv2d[0][0] __________________________________________________________________________________________________ conv2d_1 (Conv2D) (None, 32, 32, 256) 65536 conv4_block6_2_relu[0][0] __________________________________________________________________________________________________ conv2d_2 (Conv2D) (None, 32, 32, 256) 589824 conv4_block6_2_relu[0][0] __________________________________________________________________________________________________ conv2d_3 (Conv2D) (None, 32, 32, 256) 589824 conv4_block6_2_relu[0][0] __________________________________________________________________________________________________ conv2d_4 (Conv2D) (None, 32, 32, 256) 589824 conv4_block6_2_relu[0][0] __________________________________________________________________________________________________ tf.nn.relu (TFOpLambda) (None, 1, 1, 256) 0 batch_normalization[0][0] __________________________________________________________________________________________________ batch_normalization_1 (BatchNor (None, 32, 32, 256) 1024 conv2d_1[0][0] __________________________________________________________________________________________________ batch_normalization_2 (BatchNor (None, 32, 32, 256) 1024 conv2d_2[0][0] __________________________________________________________________________________________________ batch_normalization_3 (BatchNor (None, 32, 32, 256) 1024 conv2d_3[0][0] __________________________________________________________________________________________________ batch_normalization_4 (BatchNor (None, 32, 32, 256) 1024 conv2d_4[0][0] __________________________________________________________________________________________________ up_sampling2d (UpSampling2D) (None, 32, 32, 256) 0 tf.nn.relu[0][0] __________________________________________________________________________________________________ tf.nn.relu_1 (TFOpLambda) (None, 32, 32, 256) 0 batch_normalization_1[0][0] __________________________________________________________________________________________________ tf.nn.relu_2 (TFOpLambda) (None, 32, 32, 256) 0 batch_normalization_2[0][0] __________________________________________________________________________________________________ tf.nn.relu_3 (TFOpLambda) (None, 32, 32, 256) 0 batch_normalization_3[0][0] __________________________________________________________________________________________________ tf.nn.relu_4 (TFOpLambda) (None, 32, 32, 256) 0 batch_normalization_4[0][0] __________________________________________________________________________________________________ concatenate (Concatenate) (None, 32, 32, 1280) 0 up_sampling2d[0][0] tf.nn.relu_1[0][0] tf.nn.relu_2[0][0] tf.nn.relu_3[0][0] tf.nn.relu_4[0][0] __________________________________________________________________________________________________ conv2d_5 (Conv2D) (None, 32, 32, 256) 327680 concatenate[0][0] __________________________________________________________________________________________________ batch_normalization_5 (BatchNor (None, 32, 32, 256) 1024 conv2d_5[0][0] __________________________________________________________________________________________________ conv2d_6 (Conv2D) (None, 128, 128, 48) 3072 conv2_block3_2_relu[0][0] __________________________________________________________________________________________________ tf.nn.relu_5 (TFOpLambda) (None, 32, 32, 256) 0 batch_normalization_5[0][0] __________________________________________________________________________________________________ batch_normalization_6 (BatchNor (None, 128, 128, 48) 192 conv2d_6[0][0] __________________________________________________________________________________________________ up_sampling2d_1 (UpSampling2D) (None, 128, 128, 256 0 tf.nn.relu_5[0][0] __________________________________________________________________________________________________ tf.nn.relu_6 (TFOpLambda) (None, 128, 128, 48) 0 batch_normalization_6[0][0] __________________________________________________________________________________________________ concatenate_1 (Concatenate) (None, 128, 128, 304 0 up_sampling2d_1[0][0] tf.nn.relu_6[0][0] __________________________________________________________________________________________________ conv2d_7 (Conv2D) (None, 128, 128, 256 700416 concatenate_1[0][0] __________________________________________________________________________________________________ batch_normalization_7 (BatchNor (None, 128, 128, 256 1024 conv2d_7[0][0] __________________________________________________________________________________________________ tf.nn.relu_7 (TFOpLambda) (None, 128, 128, 256 0 batch_normalization_7[0][0] __________________________________________________________________________________________________ conv2d_8 (Conv2D) (None, 128, 128, 256 589824 tf.nn.relu_7[0][0] __________________________________________________________________________________________________ batch_normalization_8 (BatchNor (None, 128, 128, 256 1024 conv2d_8[0][0] __________________________________________________________________________________________________ tf.nn.relu_8 (TFOpLambda) (None, 128, 128, 256 0 batch_normalization_8[0][0] __________________________________________________________________________________________________ up_sampling2d_2 (UpSampling2D) (None, 512, 512, 256 0 tf.nn.relu_8[0][0] __________________________________________________________________________________________________ conv2d_9 (Conv2D) (None, 512, 512, 20) 5140 up_sampling2d_2[0][0] ================================================================================================== Total params: 11,857,236 Trainable params: 11,824,500 Non-trainable params: 32,736 __________________________________________________________________________________________________ Training We train the model using sparse categorical crossentropy as the loss function, and Adam as the optimizer. loss = keras.losses.SparseCategoricalCrossentropy(from_logits=True) model.compile( optimizer=keras.optimizers.Adam(learning_rate=0.001), loss=loss, metrics=[\"accuracy\"], ) history = model.fit(train_dataset, validation_data=val_dataset, epochs=25) plt.plot(history.history[\"loss\"]) plt.title(\"Training Loss\") plt.ylabel(\"loss\") plt.xlabel(\"epoch\") plt.show() plt.plot(history.history[\"accuracy\"]) plt.title(\"Training Accuracy\") plt.ylabel(\"accuracy\") plt.xlabel(\"epoch\") plt.show() plt.plot(history.history[\"val_loss\"]) plt.title(\"Validation Loss\") plt.ylabel(\"val_loss\") plt.xlabel(\"epoch\") plt.show() plt.plot(history.history[\"val_accuracy\"]) plt.title(\"Validation Accuracy\") plt.ylabel(\"val_accuracy\") plt.xlabel(\"epoch\") plt.show() Epoch 1/25 250/250 [==============================] - 115s 359ms/step - loss: 1.1765 - accuracy: 0.6424 - val_loss: 2.3559 - val_accuracy: 0.5960 Epoch 2/25 250/250 [==============================] - 92s 366ms/step - loss: 0.9413 - accuracy: 0.6998 - val_loss: 1.7349 - val_accuracy: 0.5593 Epoch 3/25 250/250 [==============================] - 93s 371ms/step - loss: 0.8415 - accuracy: 0.7310 - val_loss: 1.3097 - val_accuracy: 0.6281 Epoch 4/25 250/250 [==============================] - 93s 372ms/step - loss: 0.7640 - accuracy: 0.7552 - val_loss: 1.0175 - val_accuracy: 0.6885 Epoch 5/25 250/250 [==============================] - 93s 372ms/step - loss: 0.7139 - accuracy: 0.7706 - val_loss: 1.2226 - val_accuracy: 0.6107 Epoch 6/25 250/250 [==============================] - 93s 373ms/step - loss: 0.6647 - accuracy: 0.7867 - val_loss: 0.8583 - val_accuracy: 0.7178 Epoch 7/25 250/250 [==============================] - 94s 375ms/step - loss: 0.5986 - accuracy: 0.8080 - val_loss: 0.9724 - val_accuracy: 0.7135 Epoch 8/25 250/250 [==============================] - 93s 372ms/step - loss: 0.5599 - accuracy: 0.8212 - val_loss: 0.9722 - val_accuracy: 0.7064 Epoch 9/25 250/250 [==============================] - 93s 372ms/step - loss: 0.5161 - accuracy: 0.8364 - val_loss: 0.9023 - val_accuracy: 0.7471 Epoch 10/25 250/250 [==============================] - 93s 373ms/step - loss: 0.4719 - accuracy: 0.8515 - val_loss: 0.8803 - val_accuracy: 0.7540 Epoch 11/25 250/250 [==============================] - 93s 372ms/step - loss: 0.4337 - accuracy: 0.8636 - val_loss: 0.9682 - val_accuracy: 0.7377 Epoch 12/25 250/250 [==============================] - 93s 373ms/step - loss: 0.4079 - accuracy: 0.8718 - val_loss: 0.9586 - val_accuracy: 0.7551 Epoch 13/25 250/250 [==============================] - 93s 373ms/step - loss: 0.3694 - accuracy: 0.8856 - val_loss: 0.9676 - val_accuracy: 0.7606 Epoch 14/25 250/250 [==============================] - 93s 373ms/step - loss: 0.3493 - accuracy: 0.8913 - val_loss: 0.8375 - val_accuracy: 0.7706 Epoch 15/25 250/250 [==============================] - 93s 373ms/step - loss: 0.3217 - accuracy: 0.9008 - val_loss: 0.9956 - val_accuracy: 0.7469 Epoch 16/25 250/250 [==============================] - 93s 372ms/step - loss: 0.3018 - accuracy: 0.9075 - val_loss: 0.9614 - val_accuracy: 0.7474 Epoch 17/25 250/250 [==============================] - 93s 372ms/step - loss: 0.2870 - accuracy: 0.9122 - val_loss: 0.9652 - val_accuracy: 0.7626 Epoch 18/25 250/250 [==============================] - 93s 373ms/step - loss: 0.2685 - accuracy: 0.9182 - val_loss: 0.8913 - val_accuracy: 0.7824 Epoch 19/25 250/250 [==============================] - 93s 373ms/step - loss: 0.2574 - accuracy: 0.9216 - val_loss: 1.0205 - val_accuracy: 0.7417 Epoch 20/25 250/250 [==============================] - 93s 372ms/step - loss: 0.2619 - accuracy: 0.9199 - val_loss: 0.9237 - val_accuracy: 0.7788 Epoch 21/25 250/250 [==============================] - 93s 372ms/step - loss: 0.2372 - accuracy: 0.9280 - val_loss: 0.9076 - val_accuracy: 0.7796 Epoch 22/25 250/250 [==============================] - 93s 372ms/step - loss: 0.2175 - accuracy: 0.9344 - val_loss: 0.9797 - val_accuracy: 0.7742 Epoch 23/25 250/250 [==============================] - 93s 372ms/step - loss: 0.2084 - accuracy: 0.9370 - val_loss: 0.9981 - val_accuracy: 0.7870 Epoch 24/25 250/250 [==============================] - 93s 373ms/step - loss: 0.2077 - accuracy: 0.9370 - val_loss: 1.0494 - val_accuracy: 0.7767 Epoch 25/25 250/250 [==============================] - 93s 372ms/step - loss: 0.2059 - accuracy: 0.9377 - val_loss: 0.9640 - val_accuracy: 0.7651 png png png png Inference using Colormap Overlay The raw predictions from the model represent a one-hot encoded tensor of shape (N, 512, 512, 20) where each one of the 20 channels is a binary mask corresponding to a predicted label. In order to visualize the results, we plot them as RGB segmentation masks where each pixel is represented by a unique color corresponding to the particular label predicted. We can easily find the color corresponding to each label from the human_colormap.mat file provided as part of the dataset. We would also plot an overlay of the RGB segmentation mask on the input image as this further helps us to identify the different categories present in the image more intuitively. # Loading the Colormap colormap = loadmat( \"./instance-level_human_parsing/instance-level_human_parsing/human_colormap.mat\" )[\"colormap\"] colormap = colormap * 100 colormap = colormap.astype(np.uint8) def infer(model, image_tensor): predictions = model.predict(np.expand_dims((image_tensor), axis=0)) predictions = np.squeeze(predictions) predictions = np.argmax(predictions, axis=2) return predictions def decode_segmentation_masks(mask, colormap, n_classes): r = np.zeros_like(mask).astype(np.uint8) g = np.zeros_like(mask).astype(np.uint8) b = np.zeros_like(mask).astype(np.uint8) for l in range(0, n_classes): idx = mask == l r[idx] = colormap[l, 0] g[idx] = colormap[l, 1] b[idx] = colormap[l, 2] rgb = np.stack([r, g, b], axis=2) return rgb def get_overlay(image, colored_mask): image = tf.keras.preprocessing.image.array_to_img(image) image = np.array(image).astype(np.uint8) overlay = cv2.addWeighted(image, 0.35, colored_mask, 0.65, 0) return overlay def plot_samples_matplotlib(display_list, figsize=(5, 3)): _, axes = plt.subplots(nrows=1, ncols=len(display_list), figsize=figsize) for i in range(len(display_list)): if display_list[i].shape[-1] == 3: axes[i].imshow(tf.keras.preprocessing.image.array_to_img(display_list[i])) else: axes[i].imshow(display_list[i]) plt.show() def plot_predictions(images_list, colormap, model): for image_file in images_list: image_tensor = read_image(image_file) prediction_mask = infer(image_tensor=image_tensor, model=model) prediction_colormap = decode_segmentation_masks(prediction_mask, colormap, 20) overlay = get_overlay(image_tensor, prediction_colormap) plot_samples_matplotlib( [image_tensor, overlay, prediction_colormap], figsize=(18, 14) ) Inference on Train Images plot_predictions(train_images[:4], colormap, model=model) png png png png Inference on Validation Images plot_predictions(val_images[:4], colormap, model=model) png png png png Building a near-duplicate image search utility using deep learning and locality-sensitive hashing. Introduction Fetching similar images in (near) real time is an important use case of information retrieval systems. Some popular products utilizing it include Pinterest, Google Image Search, etc. In this example, we will build a similar image search utility using Locality Sensitive Hashing (LSH) and random projection on top of the image representations computed by a pretrained image classifier. This kind of search engine is also known as a near-duplicate (or near-dup) image detector. We will also look into optimizing the inference performance of our search utility on GPU using TensorRT. There are other examples under keras.io/examples/vision that are worth checking out in this regard: Metric learning for image similarity search Image similarity estimation using a Siamese Network with a triplet loss Finally, this example uses the following resource as a reference and as such reuses some of its code: Locality Sensitive Hashing for Similar Item Search. Note that in order to optimize the performance of our parser, you should have a GPU runtime available. Imports import matplotlib.pyplot as plt import tensorflow as tf import numpy as np import time import tensorflow_datasets as tfds tfds.disable_progress_bar() Load the dataset and create a training set of 1,000 images To keep the run time of the example short, we will be using a subset of 1,000 images from the tf_flowers dataset (available through TensorFlow Datasets) to build our vocabulary. train_ds, validation_ds = tfds.load( \"tf_flowers\", split=[\"train[:85%]\", \"train[85%:]\"], as_supervised=True ) IMAGE_SIZE = 224 NUM_IMAGES = 1000 images = [] labels = [] for (image, label) in train_ds.take(NUM_IMAGES): image = tf.image.resize(image, (IMAGE_SIZE, IMAGE_SIZE)) images.append(image.numpy()) labels.append(label.numpy()) images = np.array(images) labels = np.array(labels) Load a pre-trained model In this section, we load an image classification model that was trained on the tf_flowers dataset. 85% of the total images were used to build the training set. For more details on the training, refer to this notebook. The underlying model is a BiT-ResNet (proposed in Big Transfer (BiT): General Visual Representation Learning). The BiT-ResNet family of models is known to provide excellent transfer performance across a wide variety of different downstream tasks. !wget -q https://git.io/JuMq0 -O flower_model_bit_0.96875.zip !unzip -qq flower_model_bit_0.96875.zip bit_model = tf.keras.models.load_model(\"flower_model_bit_0.96875\") bit_model.count_params() 23510597 Create an embedding model To retrieve similar images given a query image, we need to first generate vector representations of all the images involved. We do this via an embedding model that extracts output features from our pretrained classifier and normalizes the resulting feature vectors. embedding_model = tf.keras.Sequential( [ tf.keras.layers.Input((IMAGE_SIZE, IMAGE_SIZE, 3)), tf.keras.layers.Rescaling(scale=1.0 / 255), bit_model.layers[1], tf.keras.layers.Normalization(mean=0, variance=1), ], name=\"embedding_model\", ) embedding_model.summary() Model: \"embedding_model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= rescaling (Rescaling) (None, 224, 224, 3) 0 _________________________________________________________________ keras_layer (KerasLayer) (None, 2048) 23500352 _________________________________________________________________ normalization (Normalization (None, 2048) 0 ================================================================= Total params: 23,500,352 Trainable params: 23,500,352 Non-trainable params: 0 _________________________________________________________________ Take note of the normalization layer inside the model. It is used to project the representation vectors to the space of unit-spheres. Hashing utilities def hash_func(embedding, random_vectors): embedding = np.array(embedding) # Random projection. bools = np.dot(embedding, random_vectors) > 0 return [bool2int(bool_vec) for bool_vec in bools] def bool2int(x): y = 0 for i, j in enumerate(x): if j: y += 1 << i return y The shape of the vectors coming out of embedding_model is (2048,), and considering practical aspects (storage, retrieval performance, etc.) it is quite large. So, there arises a need to reduce the dimensionality of the embedding vectors without reducing their information content. This is where random projection comes into the picture. It is based on the principle that if the distance between a group of points on a given plane is approximately preserved, the dimensionality of that plane can further be reduced. Inside hash_func(), we first reduce the dimensionality of the embedding vectors. Then we compute the bitwise hash values of the images to determine their hash buckets. Images having same hash values are likely to go into the same hash bucket. From a deployment perspective, bitwise hash values are cheaper to store and operate on. Query utilities The Table class is responsible for building a single hash table. Each entry in the hash table is a mapping between the reduced embedding of an image from our dataset and a unique identifier. Because our dimensionality reduction technique involves randomness, it can so happen that similar images are not mapped to the same hash bucket everytime the process run. To reduce this effect, we will take results from multiple tables into consideration -- the number of tables and the reduction dimensionality are the key hyperparameters here. Crucially, you wouldn't reimplement locality-sensitive hashing yourself when working with real world applications. Instead, you'd likely use one of the following popular libraries: ScaNN Annoy Vald class Table: def __init__(self, hash_size, dim): self.table = {} self.hash_size = hash_size self.random_vectors = np.random.randn(hash_size, dim).T def add(self, id, vectors, label): # Create a unique indentifier. entry = {\"id_label\": str(id) + \"_\" + str(label)} # Compute the hash values. hashes = hash_func(vectors, self.random_vectors) # Add the hash values to the current table. for h in hashes: if h in self.table: self.table[h].append(entry) else: self.table[h] = [entry] def query(self, vectors): # Compute hash value for the query vector. hashes = hash_func(vectors, self.random_vectors) results = [] # Loop over the query hashes and determine if they exist in # the current table. for h in hashes: if h in self.table: results.extend(self.table[h]) return results In the following LSH class we will pack the utilities to have multiple hash tables. class LSH: def __init__(self, hash_size, dim, num_tables): self.num_tables = num_tables self.tables = [] for i in range(self.num_tables): self.tables.append(Table(hash_size, dim)) def add(self, id, vectors, label): for table in self.tables: table.add(id, vectors, label) def query(self, vectors): results = [] for table in self.tables: results.extend(table.query(vectors)) return results Now we can encapsulate the logic for building and operating with the master LSH table (a collection of many tables) inside a class. It has two methods: train(): Responsible for building the final LSH table. query(): Computes the number of matches given a query image and also quantifies the similarity score. class BuildLSHTable: def __init__( self, prediction_model, concrete_function=False, hash_size=8, dim=2048, num_tables=10, ): self.hash_size = hash_size self.dim = dim self.num_tables = num_tables self.lsh = LSH(self.hash_size, self.dim, self.num_tables) self.prediction_model = prediction_model self.concrete_function = concrete_function def train(self, training_files): for id, training_file in enumerate(training_files): # Unpack the data. image, label = training_file if len(image.shape) < 4: image = image[None, ...] # Compute embeddings and update the LSH tables. # More on `self.concrete_function()` later. if self.concrete_function: features = self.prediction_model(tf.constant(image))[ \"normalization\" ].numpy() else: features = self.prediction_model.predict(image) self.lsh.add(id, features, label) def query(self, image, verbose=True): # Compute the embeddings of the query image and fetch the results. if len(image.shape) < 4: image = image[None, ...] if self.concrete_function: features = self.prediction_model(tf.constant(image))[ \"normalization\" ].numpy() else: features = self.prediction_model.predict(image) results = self.lsh.query(features) if verbose: print(\"Matches:\", len(results)) # Calculate Jaccard index to quantify the similarity. counts = {} for r in results: if r[\"id_label\"] in counts: counts[r[\"id_label\"]] += 1 else: counts[r[\"id_label\"]] = 1 for k in counts: counts[k] = float(counts[k]) / self.dim return counts Create LSH tables With our helper utilities and classes implemented, we can now build our LSH table. Since we will be benchmarking performance between optimized and unoptimized embedding models, we will also warm up our GPU to avoid any unfair comparison. # Utility to warm up the GPU. def warmup(): dummy_sample = tf.ones((1, IMAGE_SIZE, IMAGE_SIZE, 3)) for _ in range(100): _ = embedding_model.predict(dummy_sample) Now we can first do the GPU wam-up and proceed to build the master LSH table with embedding_model. warmup() training_files = zip(images, labels) lsh_builder = BuildLSHTable(embedding_model) lsh_builder.train(training_files) At the time of writing, the wall time was 54.1 seconds on a Tesla T4 GPU. This timing may vary based on the GPU you are using. Optimize the model with TensorRT For NVIDIA-based GPUs, the TensorRT framework can be used to dramatically enhance the inference latency by using various model optimization techniques like pruning, constant folding, layer fusion, and so on. Here we will use the tf.experimental.tensorrt module to optimize our embedding model. # First serialize the embedding model as a SavedModel. embedding_model.save(\"embedding_model\") # Initialize the conversion parameters. params = tf.experimental.tensorrt.ConversionParams( precision_mode=\"FP16\", maximum_cached_engines=16 ) # Run the conversion. converter = tf.experimental.tensorrt.Converter( input_saved_model_dir=\"embedding_model\", conversion_params=params ) converter.convert() converter.save(\"tensorrt_embedding_model\") WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model. WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model. INFO:tensorflow:Assets written to: embedding_model/assets INFO:tensorflow:Assets written to: embedding_model/assets INFO:tensorflow:Linked TensorRT version: (0, 0, 0) INFO:tensorflow:Linked TensorRT version: (0, 0, 0) INFO:tensorflow:Loaded TensorRT version: (0, 0, 0) INFO:tensorflow:Loaded TensorRT version: (0, 0, 0) INFO:tensorflow:Assets written to: tensorrt_embedding_model/assets INFO:tensorflow:Assets written to: tensorrt_embedding_model/assets Notes on the parameters inside of tf.experimental.tensorrt.ConversionParams(): precision_mode defines the numerical precision of the operations in the to-be-converted model. maximum_cached_engines specifies the maximum number of TRT engines that will be cached to handle dynamic operations (operations with unknown shapes). To learn more about the other options, refer to the official documentation. You can also explore the different quantization options provided by the tf.experimental.tensorrt module. # Load the converted model. root = tf.saved_model.load(\"tensorrt_embedding_model\") trt_model_function = root.signatures[\"serving_default\"] Build LSH tables with optimized model warmup() training_files = zip(images, labels) lsh_builder_trt = BuildLSHTable(trt_model_function, concrete_function=True) lsh_builder_trt.train(training_files) Notice the difference in the wall time which is 13.1 seconds. Earlier, with the unoptimized model it was 54.1 seconds. We can take a closer look into one of the hash tables and get an idea of how they are represented. idx = 0 for hash, entry in lsh_builder_trt.lsh.tables[0].table.items(): if idx == 5: break if len(entry) < 5: print(hash, entry) idx += 1 145 [{'id_label': '3_4'}, {'id_label': '727_3'}] 5 [{'id_label': '12_4'}] 128 [{'id_label': '30_2'}, {'id_label': '480_2'}] 208 [{'id_label': '34_2'}, {'id_label': '132_2'}, {'id_label': '984_2'}] 188 [{'id_label': '42_0'}, {'id_label': '135_3'}, {'id_label': '436_3'}, {'id_label': '670_3'}] Visualize results on validation images In this section we will first writing a couple of utility functions to visualize the similar image parsing process. Then we will benchmark the query performance of the models with and without optimization. First, we take 100 images from the validation set for testing purposes. validation_images = [] validation_labels = [] for image, label in validation_ds.take(100): image = tf.image.resize(image, (224, 224)) validation_images.append(image.numpy()) validation_labels.append(label.numpy()) validation_images = np.array(validation_images) validation_labels = np.array(validation_labels) validation_images.shape, validation_labels.shape ((100, 224, 224, 3), (100,)) Now we write our visualization utilities. def plot_images(images, labels): plt.figure(figsize=(20, 10)) columns = 5 for (i, image) in enumerate(images): ax = plt.subplot(len(images) / columns + 1, columns, i + 1) if i == 0: ax.set_title(\"Query Image\n\" + \"Label: {}\".format(labels[i])) else: ax.set_title(\"Similar Image # \" + str(i) + \"\nLabel: {}\".format(labels[i])) plt.imshow(image.astype(\"int\")) plt.axis(\"off\") def visualize_lsh(lsh_class): idx = np.random.choice(len(validation_images)) image = validation_images[idx] label = validation_labels[idx] results = lsh_class.query(image) candidates = [] labels = [] overlaps = [] for idx, r in enumerate(sorted(results, key=results.get, reverse=True)): if idx == 4: break image_id, label = r.split(\"_\")[0], r.split(\"_\")[1] candidates.append(images[int(image_id)]) labels.append(label) overlaps.append(results[r]) candidates.insert(0, image) labels.insert(0, label) plot_images(candidates, labels) Non-TRT model for _ in range(5): visualize_lsh(lsh_builder) visualize_lsh(lsh_builder) Matches: 507 Matches: 554 Matches: 438 Matches: 370 Matches: 407 Matches: 306 png png png png png png TRT model for _ in range(5): visualize_lsh(lsh_builder_trt) Matches: 458 Matches: 181 Matches: 280 Matches: 280 Matches: 503 png png png png png As you may have noticed, there are a couple of incorrect results. This can be mitigated in a few ways: Better models for generating the initial embeddings especially for noisy samples. We can use techniques like ArcFace, Supervised Contrastive Learning, etc. that implicitly encourage better learning of representations for retrieval purposes. The trade-off between the number of tables and the reduction dimensionality is crucial and helps set the right recall required for your application. Benchmarking query performance def benchmark(lsh_class): warmup() start_time = time.time() for _ in range(1000): image = np.ones((1, 224, 224, 3)).astype(\"float32\") _ = lsh_class.query(image, verbose=False) end_time = time.time() - start_time print(f\"Time taken: {end_time:.3f}\") benchmark(lsh_builder) benchmark(lsh_builder_trt) Time taken: 54.359 Time taken: 13.963 We can immediately notice a stark difference between the query performance of the two models. Final remarks In this example, we explored the TensorRT framework from NVIDIA for optimizing our model. It's best suited for GPU-based inference servers. There are other choices for such frameworks that cater to different hardware platforms: TensorFlow Lite for mobile and edge devices. ONNX for commodity CPU-based servers. Apache TVM, compiler for machine learning models covering various platforms. Here are a few resources you might want to check out to learn more about applications based on vector similary search in general: ANN Benchmarks Accelerating Large-Scale Inference with Anisotropic Vector Quantization(ScaNN) Spreading vectors for similarity search Building a real-time embeddings similarity matching system How to build and train a convolutional LSTM model for next-frame video prediction. Introduction The Convolutional LSTM architectures bring together time series processing and computer vision by introducing a convolutional recurrent cell in a LSTM layer. In this example, we will explore the Convolutional LSTM model in an application to next-frame prediction, the process of predicting what video frames come next given a series of past frames. Setup import numpy as np import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import io import imageio from IPython.display import Image, display from ipywidgets import widgets, Layout, HBox Dataset Construction For this example, we will be using the Moving MNIST dataset. We will download the dataset and then construct and preprocess training and validation sets. For next-frame prediction, our model will be using a previous frame, which we'll call f_n, to predict a new frame, called f_(n + 1). To allow the model to create these predictions, we'll need to process the data such that we have \"shifted\" inputs and outputs, where the input data is frame x_n, being used to predict frame y_(n + 1). # Download and load the dataset. fpath = keras.utils.get_file( \"moving_mnist.npy\", \"http://www.cs.toronto.edu/~nitish/unsupervised_video/mnist_test_seq.npy\", ) dataset = np.load(fpath) # Swap the axes representing the number of frames and number of data samples. dataset = np.swapaxes(dataset, 0, 1) # We'll pick out 1000 of the 10000 total examples and use those. dataset = dataset[:1000, ...] # Add a channel dimension since the images are grayscale. dataset = np.expand_dims(dataset, axis=-1) # Split into train and validation sets using indexing to optimize memory. indexes = np.arange(dataset.shape[0]) np.random.shuffle(indexes) train_index = indexes[: int(0.9 * dataset.shape[0])] val_index = indexes[int(0.9 * dataset.shape[0]) :] train_dataset = dataset[train_index] val_dataset = dataset[val_index] # Normalize the data to the 0-1 range. train_dataset = train_dataset / 255 val_dataset = val_dataset / 255 # We'll define a helper function to shift the frames, where # `x` is frames 0 to n - 1, and `y` is frames 1 to n. def create_shifted_frames(data): x = data[:, 0 : data.shape[1] - 1, :, :] y = data[:, 1 : data.shape[1], :, :] return x, y # Apply the processing function to the datasets. x_train, y_train = create_shifted_frames(train_dataset) x_val, y_val = create_shifted_frames(val_dataset) # Inspect the dataset. print(\"Training Dataset Shapes: \" + str(x_train.shape) + \", \" + str(y_train.shape)) print(\"Validation Dataset Shapes: \" + str(x_val.shape) + \", \" + str(y_val.shape)) Training Dataset Shapes: (900, 19, 64, 64, 1), (900, 19, 64, 64, 1) Validation Dataset Shapes: (100, 19, 64, 64, 1), (100, 19, 64, 64, 1) Data Visualization Our data consists of sequences of frames, each of which are used to predict the upcoming frame. Let's take a look at some of these sequential frames. # Construct a figure on which we will visualize the images. fig, axes = plt.subplots(4, 5, figsize=(10, 8)) # Plot each of the sequential images for one random data example. data_choice = np.random.choice(range(len(train_dataset)), size=1)[0] for idx, ax in enumerate(axes.flat): ax.imshow(np.squeeze(train_dataset[data_choice][idx]), cmap=\"gray\") ax.set_title(f\"Frame {idx + 1}\") ax.axis(\"off\") # Print information and display the figure. print(f\"Displaying frames for example {data_choice}.\") plt.show() Displaying frames for example 130. png Model Construction To build a Convolutional LSTM model, we will use the ConvLSTM2D layer, which will accept inputs of shape (batch_size, num_frames, width, height, channels), and return a prediction movie of the same shape. # Construct the input layer with no definite frame size. inp = layers.Input(shape=(None, *x_train.shape[2:])) # We will construct 3 `ConvLSTM2D` layers with batch normalization, # followed by a `Conv3D` layer for the spatiotemporal outputs. x = layers.ConvLSTM2D( filters=64, kernel_size=(5, 5), padding=\"same\", return_sequences=True, activation=\"relu\", )(inp) x = layers.BatchNormalization()(x) x = layers.ConvLSTM2D( filters=64, kernel_size=(3, 3), padding=\"same\", return_sequences=True, activation=\"relu\", )(x) x = layers.BatchNormalization()(x) x = layers.ConvLSTM2D( filters=64, kernel_size=(1, 1), padding=\"same\", return_sequences=True, activation=\"relu\", )(x) x = layers.Conv3D( filters=1, kernel_size=(3, 3, 3), activation=\"sigmoid\", padding=\"same\" )(x) # Next, we will build the complete model and compile it. model = keras.models.Model(inp, x) model.compile( loss=keras.losses.binary_crossentropy, optimizer=keras.optimizers.Adam(), ) Model Training With our model and data constructed, we can now train the model. # Define some callbacks to improve training. early_stopping = keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=10) reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor=\"val_loss\", patience=5) # Define modifiable training hyperparameters. epochs = 20 batch_size = 5 # Fit the model to the training data. model.fit( x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_val, y_val), callbacks=[early_stopping, reduce_lr], ) Frame Prediction Visualizations With our model now constructed and trained, we can generate some example frame predictions based on a new video. We'll pick a random example from the validation set and then choose the first ten frames from them. From there, we can allow the model to predict 10 new frames, which we can compare to the ground truth frame predictions. # Select a random example from the validation dataset. example = val_dataset[np.random.choice(range(len(val_dataset)), size=1)[0]] # Pick the first/last ten frames from the example. frames = example[:10, ...] original_frames = example[10:, ...] # Predict a new set of 10 frames. for _ in range(10): # Extract the model's prediction and post-process it. new_prediction = model.predict(np.expand_dims(frames, axis=0)) new_prediction = np.squeeze(new_prediction, axis=0) predicted_frame = np.expand_dims(new_prediction[-1, ...], axis=0) # Extend the set of prediction frames. frames = np.concatenate((frames, predicted_frame), axis=0) # Construct a figure for the original and new frames. fig, axes = plt.subplots(2, 10, figsize=(20, 4)) # Plot the original frames. for idx, ax in enumerate(axes[0]): ax.imshow(np.squeeze(original_frames[idx]), cmap=\"gray\") ax.set_title(f\"Frame {idx + 11}\") ax.axis(\"off\") # Plot the new frames. new_frames = frames[10:, ...] for idx, ax in enumerate(axes[1]): ax.imshow(np.squeeze(new_frames[idx]), cmap=\"gray\") ax.set_title(f\"Frame {idx + 11}\") ax.axis(\"off\") # Display the figure. plt.show() png Predicted Videos Finally, we'll pick a few examples from the validation set and construct some GIFs with them to see the model's predicted videos. # Select a few random examples from the dataset. examples = val_dataset[np.random.choice(range(len(val_dataset)), size=5)] # Iterate over the examples and predict the frames. predicted_videos = [] for example in examples: # Pick the first/last ten frames from the example. frames = example[:10, ...] original_frames = example[10:, ...] new_predictions = np.zeros(shape=(10, *frames[0].shape)) # Predict a new set of 10 frames. for i in range(10): # Extract the model's prediction and post-process it. frames = example[: 10 + i + 1, ...] new_prediction = model.predict(np.expand_dims(frames, axis=0)) new_prediction = np.squeeze(new_prediction, axis=0) predicted_frame = np.expand_dims(new_prediction[-1, ...], axis=0) # Extend the set of prediction frames. new_predictions[i] = predicted_frame # Create and save GIFs for each of the ground truth/prediction images. for frame_set in [original_frames, new_predictions]: # Construct a GIF from the selected video frames. current_frames = np.squeeze(frame_set) current_frames = current_frames[..., np.newaxis] * np.ones(3) current_frames = (current_frames * 255).astype(np.uint8) current_frames = list(current_frames) # Construct a GIF from the frames. with io.BytesIO() as gif: imageio.mimsave(gif, current_frames, \"GIF\", fps=5) predicted_videos.append(gif.getvalue()) # Display the videos. print(\" Truth\tPrediction\") for i in range(0, len(predicted_videos), 2): # Construct and display an `HBox` with the ground truth and prediction. box = HBox( [ widgets.Image(value=predicted_videos[i]), widgets.Image(value=predicted_videos[i + 1]), ] ) display(box) Truth Prediction Imgur Implementing RetinaNet: Focal Loss for Dense Object Detection. Introduction Object detection a very important problem in computer vision. Here the model is tasked with localizing the objects present in an image, and at the same time, classifying them into different categories. Object detection models can be broadly classified into \"single-stage\" and \"two-stage\" detectors. Two-stage detectors are often more accurate but at the cost of being slower. Here in this example, we will implement RetinaNet, a popular single-stage detector, which is accurate and runs fast. RetinaNet uses a feature pyramid network to efficiently detect objects at multiple scales and introduces a new loss, the Focal loss function, to alleviate the problem of the extreme foreground-background class imbalance. References: RetinaNet Paper Feature Pyramid Network Paper import os import re import zipfile import numpy as np import tensorflow as tf from tensorflow import keras import matplotlib.pyplot as plt import tensorflow_datasets as tfds Downloading the COCO2017 dataset Training on the entire COCO2017 dataset which has around 118k images takes a lot of time, hence we will be using a smaller subset of ~500 images for training in this example. url = \"https://github.com/srihari-humbarwadi/datasets/releases/download/v0.1.0/data.zip\" filename = os.path.join(os.getcwd(), \"data.zip\") keras.utils.get_file(filename, url) with zipfile.ZipFile(\"data.zip\", \"r\") as z_fp: z_fp.extractall(\"./\") Downloading data from https://github.com/srihari-humbarwadi/datasets/releases/download/v0.1.0/data.zip 560529408/560525318 [==============================] - 304s 1us/step Implementing utility functions Bounding boxes can be represented in multiple ways, the most common formats are: Storing the coordinates of the corners [xmin, ymin, xmax, ymax] Storing the coordinates of the center and the box dimensions [x, y, width, height] Since we require both formats, we will be implementing functions for converting between the formats. def swap_xy(boxes): \"\"\"Swaps order the of x and y coordinates of the boxes. Arguments: boxes: A tensor with shape `(num_boxes, 4)` representing bounding boxes. Returns: swapped boxes with shape same as that of boxes. \"\"\" return tf.stack([boxes[:, 1], boxes[:, 0], boxes[:, 3], boxes[:, 2]], axis=-1) def convert_to_xywh(boxes): \"\"\"Changes the box format to center, width and height. Arguments: boxes: A tensor of rank 2 or higher with a shape of `(..., num_boxes, 4)` representing bounding boxes where each box is of the format `[xmin, ymin, xmax, ymax]`. Returns: converted boxes with shape same as that of boxes. \"\"\" return tf.concat( [(boxes[..., :2] + boxes[..., 2:]) / 2.0, boxes[..., 2:] - boxes[..., :2]], axis=-1, ) def convert_to_corners(boxes): \"\"\"Changes the box format to corner coordinates Arguments: boxes: A tensor of rank 2 or higher with a shape of `(..., num_boxes, 4)` representing bounding boxes where each box is of the format `[x, y, width, height]`. Returns: converted boxes with shape same as that of boxes. \"\"\" return tf.concat( [boxes[..., :2] - boxes[..., 2:] / 2.0, boxes[..., :2] + boxes[..., 2:] / 2.0], axis=-1, ) Computing pairwise Intersection Over Union (IOU) As we will see later in the example, we would be assigning ground truth boxes to anchor boxes based on the extent of overlapping. This will require us to calculate the Intersection Over Union (IOU) between all the anchor boxes and ground truth boxes pairs. def compute_iou(boxes1, boxes2): \"\"\"Computes pairwise IOU matrix for given two sets of boxes Arguments: boxes1: A tensor with shape `(N, 4)` representing bounding boxes where each box is of the format `[x, y, width, height]`. boxes2: A tensor with shape `(M, 4)` representing bounding boxes where each box is of the format `[x, y, width, height]`. Returns: pairwise IOU matrix with shape `(N, M)`, where the value at ith row jth column holds the IOU between ith box and jth box from boxes1 and boxes2 respectively. \"\"\" boxes1_corners = convert_to_corners(boxes1) boxes2_corners = convert_to_corners(boxes2) lu = tf.maximum(boxes1_corners[:, None, :2], boxes2_corners[:, :2]) rd = tf.minimum(boxes1_corners[:, None, 2:], boxes2_corners[:, 2:]) intersection = tf.maximum(0.0, rd - lu) intersection_area = intersection[:, :, 0] * intersection[:, :, 1] boxes1_area = boxes1[:, 2] * boxes1[:, 3] boxes2_area = boxes2[:, 2] * boxes2[:, 3] union_area = tf.maximum( boxes1_area[:, None] + boxes2_area - intersection_area, 1e-8 ) return tf.clip_by_value(intersection_area / union_area, 0.0, 1.0) def visualize_detections( image, boxes, classes, scores, figsize=(7, 7), linewidth=1, color=[0, 0, 1] ): \"\"\"Visualize Detections\"\"\" image = np.array(image, dtype=np.uint8) plt.figure(figsize=figsize) plt.axis(\"off\") plt.imshow(image) ax = plt.gca() for box, _cls, score in zip(boxes, classes, scores): text = \"{}: {:.2f}\".format(_cls, score) x1, y1, x2, y2 = box w, h = x2 - x1, y2 - y1 patch = plt.Rectangle( [x1, y1], w, h, fill=False, edgecolor=color, linewidth=linewidth ) ax.add_patch(patch) ax.text( x1, y1, text, bbox={\"facecolor\": color, \"alpha\": 0.4}, clip_box=ax.clipbox, clip_on=True, ) plt.show() return ax Implementing Anchor generator Anchor boxes are fixed sized boxes that the model uses to predict the bounding box for an object. It does this by regressing the offset between the location of the object's center and the center of an anchor box, and then uses the width and height of the anchor box to predict a relative scale of the object. In the case of RetinaNet, each location on a given feature map has nine anchor boxes (at three scales and three ratios). class AnchorBox: \"\"\"Generates anchor boxes. This class has operations to generate anchor boxes for feature maps at strides `[8, 16, 32, 64, 128]`. Where each anchor each box is of the format `[x, y, width, height]`. Attributes: aspect_ratios: A list of float values representing the aspect ratios of the anchor boxes at each location on the feature map scales: A list of float values representing the scale of the anchor boxes at each location on the feature map. num_anchors: The number of anchor boxes at each location on feature map areas: A list of float values representing the areas of the anchor boxes for each feature map in the feature pyramid. strides: A list of float value representing the strides for each feature map in the feature pyramid. \"\"\" def __init__(self): self.aspect_ratios = [0.5, 1.0, 2.0] self.scales = [2 ** x for x in [0, 1 / 3, 2 / 3]] self._num_anchors = len(self.aspect_ratios) * len(self.scales) self._strides = [2 ** i for i in range(3, 8)] self._areas = [x ** 2 for x in [32.0, 64.0, 128.0, 256.0, 512.0]] self._anchor_dims = self._compute_dims() def _compute_dims(self): \"\"\"Computes anchor box dimensions for all ratios and scales at all levels of the feature pyramid. \"\"\" anchor_dims_all = [] for area in self._areas: anchor_dims = [] for ratio in self.aspect_ratios: anchor_height = tf.math.sqrt(area / ratio) anchor_width = area / anchor_height dims = tf.reshape( tf.stack([anchor_width, anchor_height], axis=-1), [1, 1, 2] ) for scale in self.scales: anchor_dims.append(scale * dims) anchor_dims_all.append(tf.stack(anchor_dims, axis=-2)) return anchor_dims_all def _get_anchors(self, feature_height, feature_width, level): \"\"\"Generates anchor boxes for a given feature map size and level Arguments: feature_height: An integer representing the height of the feature map. feature_width: An integer representing the width of the feature map. level: An integer representing the level of the feature map in the feature pyramid. Returns: anchor boxes with the shape `(feature_height * feature_width * num_anchors, 4)` \"\"\" rx = tf.range(feature_width, dtype=tf.float32) + 0.5 ry = tf.range(feature_height, dtype=tf.float32) + 0.5 centers = tf.stack(tf.meshgrid(rx, ry), axis=-1) * self._strides[level - 3] centers = tf.expand_dims(centers, axis=-2) centers = tf.tile(centers, [1, 1, self._num_anchors, 1]) dims = tf.tile( self._anchor_dims[level - 3], [feature_height, feature_width, 1, 1] ) anchors = tf.concat([centers, dims], axis=-1) return tf.reshape( anchors, [feature_height * feature_width * self._num_anchors, 4] ) def get_anchors(self, image_height, image_width): \"\"\"Generates anchor boxes for all the feature maps of the feature pyramid. Arguments: image_height: Height of the input image. image_width: Width of the input image. Returns: anchor boxes for all the feature maps, stacked as a single tensor with shape `(total_anchors, 4)` \"\"\" anchors = [ self._get_anchors( tf.math.ceil(image_height / 2 ** i), tf.math.ceil(image_width / 2 ** i), i, ) for i in range(3, 8) ] return tf.concat(anchors, axis=0) Preprocessing data Preprocessing the images involves two steps: Resizing the image: Images are resized such that the shortest size is equal to 800 px, after resizing if the longest side of the image exceeds 1333 px, the image is resized such that the longest size is now capped at 1333 px. Applying augmentation: Random scale jittering and random horizontal flipping are the only augmentations applied to the images. Along with the images, bounding boxes are rescaled and flipped if required. def random_flip_horizontal(image, boxes): \"\"\"Flips image and boxes horizontally with 50% chance Arguments: image: A 3-D tensor of shape `(height, width, channels)` representing an image. boxes: A tensor with shape `(num_boxes, 4)` representing bounding boxes, having normalized coordinates. Returns: Randomly flipped image and boxes \"\"\" if tf.random.uniform(()) > 0.5: image = tf.image.flip_left_right(image) boxes = tf.stack( [1 - boxes[:, 2], boxes[:, 1], 1 - boxes[:, 0], boxes[:, 3]], axis=-1 ) return image, boxes def resize_and_pad_image( image, min_side=800.0, max_side=1333.0, jitter=[640, 1024], stride=128.0 ): \"\"\"Resizes and pads image while preserving aspect ratio. 1. Resizes images so that the shorter side is equal to `min_side` 2. If the longer side is greater than `max_side`, then resize the image with longer side equal to `max_side` 3. Pad with zeros on right and bottom to make the image shape divisible by `stride` Arguments: image: A 3-D tensor of shape `(height, width, channels)` representing an image. min_side: The shorter side of the image is resized to this value, if `jitter` is set to None. max_side: If the longer side of the image exceeds this value after resizing, the image is resized such that the longer side now equals to this value. jitter: A list of floats containing minimum and maximum size for scale jittering. If available, the shorter side of the image will be resized to a random value in this range. stride: The stride of the smallest feature map in the feature pyramid. Can be calculated using `image_size / feature_map_size`. Returns: image: Resized and padded image. image_shape: Shape of the image before padding. ratio: The scaling factor used to resize the image \"\"\" image_shape = tf.cast(tf.shape(image)[:2], dtype=tf.float32) if jitter is not None: min_side = tf.random.uniform((), jitter[0], jitter[1], dtype=tf.float32) ratio = min_side / tf.reduce_min(image_shape) if ratio * tf.reduce_max(image_shape) > max_side: ratio = max_side / tf.reduce_max(image_shape) image_shape = ratio * image_shape image = tf.image.resize(image, tf.cast(image_shape, dtype=tf.int32)) padded_image_shape = tf.cast( tf.math.ceil(image_shape / stride) * stride, dtype=tf.int32 ) image = tf.image.pad_to_bounding_box( image, 0, 0, padded_image_shape[0], padded_image_shape[1] ) return image, image_shape, ratio def preprocess_data(sample): \"\"\"Applies preprocessing step to a single sample Arguments: sample: A dict representing a single training sample. Returns: image: Resized and padded image with random horizontal flipping applied. bbox: Bounding boxes with the shape `(num_objects, 4)` where each box is of the format `[x, y, width, height]`. class_id: An tensor representing the class id of the objects, having shape `(num_objects,)`. \"\"\" image = sample[\"image\"] bbox = swap_xy(sample[\"objects\"][\"bbox\"]) class_id = tf.cast(sample[\"objects\"][\"label\"], dtype=tf.int32) image, bbox = random_flip_horizontal(image, bbox) image, image_shape, _ = resize_and_pad_image(image) bbox = tf.stack( [ bbox[:, 0] * image_shape[1], bbox[:, 1] * image_shape[0], bbox[:, 2] * image_shape[1], bbox[:, 3] * image_shape[0], ], axis=-1, ) bbox = convert_to_xywh(bbox) return image, bbox, class_id Encoding labels The raw labels, consisting of bounding boxes and class ids need to be transformed into targets for training. This transformation consists of the following steps: Generating anchor boxes for the given image dimensions Assigning ground truth boxes to the anchor boxes The anchor boxes that are not assigned any objects, are either assigned the background class or ignored depending on the IOU Generating the classification and regression targets using anchor boxes class LabelEncoder: \"\"\"Transforms the raw labels into targets for training. This class has operations to generate targets for a batch of samples which is made up of the input images, bounding boxes for the objects present and their class ids. Attributes: anchor_box: Anchor box generator to encode the bounding boxes. box_variance: The scaling factors used to scale the bounding box targets. \"\"\" def __init__(self): self._anchor_box = AnchorBox() self._box_variance = tf.convert_to_tensor( [0.1, 0.1, 0.2, 0.2], dtype=tf.float32 ) def _match_anchor_boxes( self, anchor_boxes, gt_boxes, match_iou=0.5, ignore_iou=0.4 ): \"\"\"Matches ground truth boxes to anchor boxes based on IOU. 1. Calculates the pairwise IOU for the M `anchor_boxes` and N `gt_boxes` to get a `(M, N)` shaped matrix. 2. The ground truth box with the maximum IOU in each row is assigned to the anchor box provided the IOU is greater than `match_iou`. 3. If the maximum IOU in a row is less than `ignore_iou`, the anchor box is assigned with the background class. 4. The remaining anchor boxes that do not have any class assigned are ignored during training. Arguments: anchor_boxes: A float tensor with the shape `(total_anchors, 4)` representing all the anchor boxes for a given input image shape, where each anchor box is of the format `[x, y, width, height]`. gt_boxes: A float tensor with shape `(num_objects, 4)` representing the ground truth boxes, where each box is of the format `[x, y, width, height]`. match_iou: A float value representing the minimum IOU threshold for determining if a ground truth box can be assigned to an anchor box. ignore_iou: A float value representing the IOU threshold under which an anchor box is assigned to the background class. Returns: matched_gt_idx: Index of the matched object positive_mask: A mask for anchor boxes that have been assigned ground truth boxes. ignore_mask: A mask for anchor boxes that need to by ignored during training \"\"\" iou_matrix = compute_iou(anchor_boxes, gt_boxes) max_iou = tf.reduce_max(iou_matrix, axis=1) matched_gt_idx = tf.argmax(iou_matrix, axis=1) positive_mask = tf.greater_equal(max_iou, match_iou) negative_mask = tf.less(max_iou, ignore_iou) ignore_mask = tf.logical_not(tf.logical_or(positive_mask, negative_mask)) return ( matched_gt_idx, tf.cast(positive_mask, dtype=tf.float32), tf.cast(ignore_mask, dtype=tf.float32), ) def _compute_box_target(self, anchor_boxes, matched_gt_boxes): \"\"\"Transforms the ground truth boxes into targets for training\"\"\" box_target = tf.concat( [ (matched_gt_boxes[:, :2] - anchor_boxes[:, :2]) / anchor_boxes[:, 2:], tf.math.log(matched_gt_boxes[:, 2:] / anchor_boxes[:, 2:]), ], axis=-1, ) box_target = box_target / self._box_variance return box_target def _encode_sample(self, image_shape, gt_boxes, cls_ids): \"\"\"Creates box and classification targets for a single sample\"\"\" anchor_boxes = self._anchor_box.get_anchors(image_shape[1], image_shape[2]) cls_ids = tf.cast(cls_ids, dtype=tf.float32) matched_gt_idx, positive_mask, ignore_mask = self._match_anchor_boxes( anchor_boxes, gt_boxes ) matched_gt_boxes = tf.gather(gt_boxes, matched_gt_idx) box_target = self._compute_box_target(anchor_boxes, matched_gt_boxes) matched_gt_cls_ids = tf.gather(cls_ids, matched_gt_idx) cls_target = tf.where( tf.not_equal(positive_mask, 1.0), -1.0, matched_gt_cls_ids ) cls_target = tf.where(tf.equal(ignore_mask, 1.0), -2.0, cls_target) cls_target = tf.expand_dims(cls_target, axis=-1) label = tf.concat([box_target, cls_target], axis=-1) return label def encode_batch(self, batch_images, gt_boxes, cls_ids): \"\"\"Creates box and classification targets for a batch\"\"\" images_shape = tf.shape(batch_images) batch_size = images_shape[0] labels = tf.TensorArray(dtype=tf.float32, size=batch_size, dynamic_size=True) for i in range(batch_size): label = self._encode_sample(images_shape, gt_boxes[i], cls_ids[i]) labels = labels.write(i, label) batch_images = tf.keras.applications.resnet.preprocess_input(batch_images) return batch_images, labels.stack() Building the ResNet50 backbone RetinaNet uses a ResNet based backbone, using which a feature pyramid network is constructed. In the example we use ResNet50 as the backbone, and return the feature maps at strides 8, 16 and 32. def get_backbone(): \"\"\"Builds ResNet50 with pre-trained imagenet weights\"\"\" backbone = keras.applications.ResNet50( include_top=False, input_shape=[None, None, 3] ) c3_output, c4_output, c5_output = [ backbone.get_layer(layer_name).output for layer_name in [\"conv3_block4_out\", \"conv4_block6_out\", \"conv5_block3_out\"] ] return keras.Model( inputs=[backbone.inputs], outputs=[c3_output, c4_output, c5_output] ) Building Feature Pyramid Network as a custom layer class FeaturePyramid(keras.layers.Layer): \"\"\"Builds the Feature Pyramid with the feature maps from the backbone. Attributes: num_classes: Number of classes in the dataset. backbone: The backbone to build the feature pyramid from. Currently supports ResNet50 only. \"\"\" def __init__(self, backbone=None, **kwargs): super(FeaturePyramid, self).__init__(name=\"FeaturePyramid\", **kwargs) self.backbone = backbone if backbone else get_backbone() self.conv_c3_1x1 = keras.layers.Conv2D(256, 1, 1, \"same\") self.conv_c4_1x1 = keras.layers.Conv2D(256, 1, 1, \"same\") self.conv_c5_1x1 = keras.layers.Conv2D(256, 1, 1, \"same\") self.conv_c3_3x3 = keras.layers.Conv2D(256, 3, 1, \"same\") self.conv_c4_3x3 = keras.layers.Conv2D(256, 3, 1, \"same\") self.conv_c5_3x3 = keras.layers.Conv2D(256, 3, 1, \"same\") self.conv_c6_3x3 = keras.layers.Conv2D(256, 3, 2, \"same\") self.conv_c7_3x3 = keras.layers.Conv2D(256, 3, 2, \"same\") self.upsample_2x = keras.layers.UpSampling2D(2) def call(self, images, training=False): c3_output, c4_output, c5_output = self.backbone(images, training=training) p3_output = self.conv_c3_1x1(c3_output) p4_output = self.conv_c4_1x1(c4_output) p5_output = self.conv_c5_1x1(c5_output) p4_output = p4_output + self.upsample_2x(p5_output) p3_output = p3_output + self.upsample_2x(p4_output) p3_output = self.conv_c3_3x3(p3_output) p4_output = self.conv_c4_3x3(p4_output) p5_output = self.conv_c5_3x3(p5_output) p6_output = self.conv_c6_3x3(c5_output) p7_output = self.conv_c7_3x3(tf.nn.relu(p6_output)) return p3_output, p4_output, p5_output, p6_output, p7_output Building the classification and box regression heads. The RetinaNet model has separate heads for bounding box regression and for predicting class probabilities for the objects. These heads are shared between all the feature maps of the feature pyramid. def build_head(output_filters, bias_init): \"\"\"Builds the class/box predictions head. Arguments: output_filters: Number of convolution filters in the final layer. bias_init: Bias Initializer for the final convolution layer. Returns: A keras sequential model representing either the classification or the box regression head depending on `output_filters`. \"\"\" head = keras.Sequential([keras.Input(shape=[None, None, 256])]) kernel_init = tf.initializers.RandomNormal(0.0, 0.01) for _ in range(4): head.add( keras.layers.Conv2D(256, 3, padding=\"same\", kernel_initializer=kernel_init) ) head.add(keras.layers.ReLU()) head.add( keras.layers.Conv2D( output_filters, 3, 1, padding=\"same\", kernel_initializer=kernel_init, bias_initializer=bias_init, ) ) return head Building RetinaNet using a subclassed model class RetinaNet(keras.Model): \"\"\"A subclassed Keras model implementing the RetinaNet architecture. Attributes: num_classes: Number of classes in the dataset. backbone: The backbone to build the feature pyramid from. Currently supports ResNet50 only. \"\"\" def __init__(self, num_classes, backbone=None, **kwargs): super(RetinaNet, self).__init__(name=\"RetinaNet\", **kwargs) self.fpn = FeaturePyramid(backbone) self.num_classes = num_classes prior_probability = tf.constant_initializer(-np.log((1 - 0.01) / 0.01)) self.cls_head = build_head(9 * num_classes, prior_probability) self.box_head = build_head(9 * 4, \"zeros\") def call(self, image, training=False): features = self.fpn(image, training=training) N = tf.shape(image)[0] cls_outputs = [] box_outputs = [] for feature in features: box_outputs.append(tf.reshape(self.box_head(feature), [N, -1, 4])) cls_outputs.append( tf.reshape(self.cls_head(feature), [N, -1, self.num_classes]) ) cls_outputs = tf.concat(cls_outputs, axis=1) box_outputs = tf.concat(box_outputs, axis=1) return tf.concat([box_outputs, cls_outputs], axis=-1) Implementing a custom layer to decode predictions class DecodePredictions(tf.keras.layers.Layer): \"\"\"A Keras layer that decodes predictions of the RetinaNet model. Attributes: num_classes: Number of classes in the dataset confidence_threshold: Minimum class probability, below which detections are pruned. nms_iou_threshold: IOU threshold for the NMS operation max_detections_per_class: Maximum number of detections to retain per class. max_detections: Maximum number of detections to retain across all classes. box_variance: The scaling factors used to scale the bounding box predictions. \"\"\" def __init__( self, num_classes=80, confidence_threshold=0.05, nms_iou_threshold=0.5, max_detections_per_class=100, max_detections=100, box_variance=[0.1, 0.1, 0.2, 0.2], **kwargs ): super(DecodePredictions, self).__init__(**kwargs) self.num_classes = num_classes self.confidence_threshold = confidence_threshold self.nms_iou_threshold = nms_iou_threshold self.max_detections_per_class = max_detections_per_class self.max_detections = max_detections self._anchor_box = AnchorBox() self._box_variance = tf.convert_to_tensor( [0.1, 0.1, 0.2, 0.2], dtype=tf.float32 ) def _decode_box_predictions(self, anchor_boxes, box_predictions): boxes = box_predictions * self._box_variance boxes = tf.concat( [ boxes[:, :, :2] * anchor_boxes[:, :, 2:] + anchor_boxes[:, :, :2], tf.math.exp(boxes[:, :, 2:]) * anchor_boxes[:, :, 2:], ], axis=-1, ) boxes_transformed = convert_to_corners(boxes) return boxes_transformed def call(self, images, predictions): image_shape = tf.cast(tf.shape(images), dtype=tf.float32) anchor_boxes = self._anchor_box.get_anchors(image_shape[1], image_shape[2]) box_predictions = predictions[:, :, :4] cls_predictions = tf.nn.sigmoid(predictions[:, :, 4:]) boxes = self._decode_box_predictions(anchor_boxes[None, ...], box_predictions) return tf.image.combined_non_max_suppression( tf.expand_dims(boxes, axis=2), cls_predictions, self.max_detections_per_class, self.max_detections, self.nms_iou_threshold, self.confidence_threshold, clip_boxes=False, ) Implementing Smooth L1 loss and Focal Loss as keras custom losses class RetinaNetBoxLoss(tf.losses.Loss): \"\"\"Implements Smooth L1 loss\"\"\" def __init__(self, delta): super(RetinaNetBoxLoss, self).__init__( reduction=\"none\", name=\"RetinaNetBoxLoss\" ) self._delta = delta def call(self, y_true, y_pred): difference = y_true - y_pred absolute_difference = tf.abs(difference) squared_difference = difference ** 2 loss = tf.where( tf.less(absolute_difference, self._delta), 0.5 * squared_difference, absolute_difference - 0.5, ) return tf.reduce_sum(loss, axis=-1) class RetinaNetClassificationLoss(tf.losses.Loss): \"\"\"Implements Focal loss\"\"\" def __init__(self, alpha, gamma): super(RetinaNetClassificationLoss, self).__init__( reduction=\"none\", name=\"RetinaNetClassificationLoss\" ) self._alpha = alpha self._gamma = gamma def call(self, y_true, y_pred): cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits( labels=y_true, logits=y_pred ) probs = tf.nn.sigmoid(y_pred) alpha = tf.where(tf.equal(y_true, 1.0), self._alpha, (1.0 - self._alpha)) pt = tf.where(tf.equal(y_true, 1.0), probs, 1 - probs) loss = alpha * tf.pow(1.0 - pt, self._gamma) * cross_entropy return tf.reduce_sum(loss, axis=-1) class RetinaNetLoss(tf.losses.Loss): \"\"\"Wrapper to combine both the losses\"\"\" def __init__(self, num_classes=80, alpha=0.25, gamma=2.0, delta=1.0): super(RetinaNetLoss, self).__init__(reduction=\"auto\", name=\"RetinaNetLoss\") self._clf_loss = RetinaNetClassificationLoss(alpha, gamma) self._box_loss = RetinaNetBoxLoss(delta) self._num_classes = num_classes def call(self, y_true, y_pred): y_pred = tf.cast(y_pred, dtype=tf.float32) box_labels = y_true[:, :, :4] box_predictions = y_pred[:, :, :4] cls_labels = tf.one_hot( tf.cast(y_true[:, :, 4], dtype=tf.int32), depth=self._num_classes, dtype=tf.float32, ) cls_predictions = y_pred[:, :, 4:] positive_mask = tf.cast(tf.greater(y_true[:, :, 4], -1.0), dtype=tf.float32) ignore_mask = tf.cast(tf.equal(y_true[:, :, 4], -2.0), dtype=tf.float32) clf_loss = self._clf_loss(cls_labels, cls_predictions) box_loss = self._box_loss(box_labels, box_predictions) clf_loss = tf.where(tf.equal(ignore_mask, 1.0), 0.0, clf_loss) box_loss = tf.where(tf.equal(positive_mask, 1.0), box_loss, 0.0) normalizer = tf.reduce_sum(positive_mask, axis=-1) clf_loss = tf.math.divide_no_nan(tf.reduce_sum(clf_loss, axis=-1), normalizer) box_loss = tf.math.divide_no_nan(tf.reduce_sum(box_loss, axis=-1), normalizer) loss = clf_loss + box_loss return loss Setting up training parameters model_dir = \"retinanet/\" label_encoder = LabelEncoder() num_classes = 80 batch_size = 2 learning_rates = [2.5e-06, 0.000625, 0.00125, 0.0025, 0.00025, 2.5e-05] learning_rate_boundaries = [125, 250, 500, 240000, 360000] learning_rate_fn = tf.optimizers.schedules.PiecewiseConstantDecay( boundaries=learning_rate_boundaries, values=learning_rates ) Initializing and compiling model resnet50_backbone = get_backbone() loss_fn = RetinaNetLoss(num_classes) model = RetinaNet(num_classes, resnet50_backbone) optimizer = tf.optimizers.SGD(learning_rate=learning_rate_fn, momentum=0.9) model.compile(loss=loss_fn, optimizer=optimizer) Setting up callbacks callbacks_list = [ tf.keras.callbacks.ModelCheckpoint( filepath=os.path.join(model_dir, \"weights\" + \"_epoch_{epoch}\"), monitor=\"loss\", save_best_only=False, save_weights_only=True, verbose=1, ) ] Load the COCO2017 dataset using TensorFlow Datasets # set `data_dir=None` to load the complete dataset (train_dataset, val_dataset), dataset_info = tfds.load( \"coco/2017\", split=[\"train\", \"validation\"], with_info=True, data_dir=\"data\" ) Setting up a tf.data pipeline To ensure that the model is fed with data efficiently we will be using tf.data API to create our input pipeline. The input pipeline consists for the following major processing steps: Apply the preprocessing function to the samples Create batches with fixed batch size. Since images in the batch can have different dimensions, and can also have different number of objects, we use padded_batch to the add the necessary padding to create rectangular tensors Create targets for each sample in the batch using LabelEncoder autotune = tf.data.AUTOTUNE train_dataset = train_dataset.map(preprocess_data, num_parallel_calls=autotune) train_dataset = train_dataset.shuffle(8 * batch_size) train_dataset = train_dataset.padded_batch( batch_size=batch_size, padding_values=(0.0, 1e-8, -1), drop_remainder=True ) train_dataset = train_dataset.map( label_encoder.encode_batch, num_parallel_calls=autotune ) train_dataset = train_dataset.apply(tf.data.experimental.ignore_errors()) train_dataset = train_dataset.prefetch(autotune) val_dataset = val_dataset.map(preprocess_data, num_parallel_calls=autotune) val_dataset = val_dataset.padded_batch( batch_size=1, padding_values=(0.0, 1e-8, -1), drop_remainder=True ) val_dataset = val_dataset.map(label_encoder.encode_batch, num_parallel_calls=autotune) val_dataset = val_dataset.apply(tf.data.experimental.ignore_errors()) val_dataset = val_dataset.prefetch(autotune) Training the model # Uncomment the following lines, when training on full dataset # train_steps_per_epoch = dataset_info.splits[\"train\"].num_examples // batch_size # val_steps_per_epoch = \ # dataset_info.splits[\"validation\"].num_examples // batch_size # train_steps = 4 * 100000 # epochs = train_steps // train_steps_per_epoch epochs = 1 # Running 100 training and 50 validation steps, # remove `.take` when training on the full dataset model.fit( train_dataset.take(100), validation_data=val_dataset.take(50), epochs=epochs, callbacks=callbacks_list, verbose=1, ) 100/100 [==============================] - ETA: 0s - loss: 4.0953 Epoch 00001: saving model to retinanet/weights_epoch_1 100/100 [==============================] - 68s 679ms/step - loss: 4.0953 - val_loss: 4.0821 Loading weights # Change this to `model_dir` when not using the downloaded weights weights_dir = \"data\" latest_checkpoint = tf.train.latest_checkpoint(weights_dir) model.load_weights(latest_checkpoint) Building inference model image = tf.keras.Input(shape=[None, None, 3], name=\"image\") predictions = model(image, training=False) detections = DecodePredictions(confidence_threshold=0.5)(image, predictions) inference_model = tf.keras.Model(inputs=image, outputs=detections) Generating detections def prepare_image(image): image, _, ratio = resize_and_pad_image(image, jitter=None) image = tf.keras.applications.resnet.preprocess_input(image) return tf.expand_dims(image, axis=0), ratio val_dataset = tfds.load(\"coco/2017\", split=\"validation\", data_dir=\"data\") int2str = dataset_info.features[\"objects\"][\"label\"].int2str for sample in val_dataset.take(2): image = tf.cast(sample[\"image\"], dtype=tf.float32) input_image, ratio = prepare_image(image) detections = inference_model.predict(input_image) num_detections = detections.valid_detections[0] class_names = [ int2str(int(x)) for x in detections.nmsed_classes[0][:num_detections] ] visualize_detections( image, detections.nmsed_boxes[0][:num_detections] / ratio, class_names, detections.nmsed_scores[0][:num_detections], ) png png How to implement an OCR model using CNNs, RNNs and CTC loss. Introduction This example demonstrates a simple OCR model built with the Functional API. Apart from combining CNN and RNN, it also illustrates how you can instantiate a new layer and use it as an \"Endpoint layer\" for implementing CTC loss. For a detailed guide to layer subclassing, please check out this page in the developer guides. Setup import os import numpy as np import matplotlib.pyplot as plt from pathlib import Path from collections import Counter import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Load the data: Captcha Images Let's download the data. !curl -LO https://github.com/AakashKumarNain/CaptchaCracker/raw/master/captcha_images_v2.zip !unzip -qq captcha_images_v2.zip % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 159 100 159 0 0 164 0 --:--:-- --:--:-- --:--:-- 164 100 8863k 100 8863k 0 0 4882k 0 0:00:01 0:00:01 --:--:-- 33.0M The dataset contains 1040 captcha files as png images. The label for each sample is a string, the name of the file (minus the file extension). We will map each character in the string to an integer for training the model. Similary, we will need to map the predictions of the model back to strings. For this purpose we will maintain two dictionaries, mapping characters to integers, and integers to characters, respectively. # Path to the data directory data_dir = Path(\"./captcha_images_v2/\") # Get list of all the images images = sorted(list(map(str, list(data_dir.glob(\"*.png\"))))) labels = [img.split(os.path.sep)[-1].split(\".png\")[0] for img in images] characters = set(char for label in labels for char in label) print(\"Number of images found: \", len(images)) print(\"Number of labels found: \", len(labels)) print(\"Number of unique characters: \", len(characters)) print(\"Characters present: \", characters) # Batch size for training and validation batch_size = 16 # Desired image dimensions img_width = 200 img_height = 50 # Factor by which the image is going to be downsampled # by the convolutional blocks. We will be using two # convolution blocks and each block will have # a pooling layer which downsample the features by a factor of 2. # Hence total downsampling factor would be 4. downsample_factor = 4 # Maximum length of any captcha in the dataset max_length = max([len(label) for label in labels]) Number of images found: 1040 Number of labels found: 1040 Number of unique characters: 19 Characters present: {'d', 'w', 'y', '4', 'f', '6', 'g', 'e', '3', '5', 'p', 'x', '2', 'c', '7', 'n', 'b', '8', 'm'} Preprocessing # Mapping characters to integers char_to_num = layers.StringLookup( vocabulary=list(characters), mask_token=None ) # Mapping integers back to original characters num_to_char = layers.StringLookup( vocabulary=char_to_num.get_vocabulary(), mask_token=None, invert=True ) def split_data(images, labels, train_size=0.9, shuffle=True): # 1. Get the total size of the dataset size = len(images) # 2. Make an indices array and shuffle it, if required indices = np.arange(size) if shuffle: np.random.shuffle(indices) # 3. Get the size of training samples train_samples = int(size * train_size) # 4. Split data into training and validation sets x_train, y_train = images[indices[:train_samples]], labels[indices[:train_samples]] x_valid, y_valid = images[indices[train_samples:]], labels[indices[train_samples:]] return x_train, x_valid, y_train, y_valid # Splitting data into training and validation sets x_train, x_valid, y_train, y_valid = split_data(np.array(images), np.array(labels)) def encode_single_sample(img_path, label): # 1. Read image img = tf.io.read_file(img_path) # 2. Decode and convert to grayscale img = tf.io.decode_png(img, channels=1) # 3. Convert to float32 in [0, 1] range img = tf.image.convert_image_dtype(img, tf.float32) # 4. Resize to the desired size img = tf.image.resize(img, [img_height, img_width]) # 5. Transpose the image because we want the time # dimension to correspond to the width of the image. img = tf.transpose(img, perm=[1, 0, 2]) # 6. Map the characters in label to numbers label = char_to_num(tf.strings.unicode_split(label, input_encoding=\"UTF-8\")) # 7. Return a dict as our model is expecting two inputs return {\"image\": img, \"label\": label} Create Dataset objects train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) train_dataset = ( train_dataset.map( encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE ) .batch(batch_size) .prefetch(buffer_size=tf.data.AUTOTUNE) ) validation_dataset = tf.data.Dataset.from_tensor_slices((x_valid, y_valid)) validation_dataset = ( validation_dataset.map( encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE ) .batch(batch_size) .prefetch(buffer_size=tf.data.AUTOTUNE) ) Visualize the data _, ax = plt.subplots(4, 4, figsize=(10, 5)) for batch in train_dataset.take(1): images = batch[\"image\"] labels = batch[\"label\"] for i in range(16): img = (images[i] * 255).numpy().astype(\"uint8\") label = tf.strings.reduce_join(num_to_char(labels[i])).numpy().decode(\"utf-8\") ax[i // 4, i % 4].imshow(img[:, :, 0].T, cmap=\"gray\") ax[i // 4, i % 4].set_title(label) ax[i // 4, i % 4].axis(\"off\") plt.show() png Model class CTCLayer(layers.Layer): def __init__(self, name=None): super().__init__(name=name) self.loss_fn = keras.backend.ctc_batch_cost def call(self, y_true, y_pred): # Compute the training-time loss value and add it # to the layer using `self.add_loss()`. batch_len = tf.cast(tf.shape(y_true)[0], dtype=\"int64\") input_length = tf.cast(tf.shape(y_pred)[1], dtype=\"int64\") label_length = tf.cast(tf.shape(y_true)[1], dtype=\"int64\") input_length = input_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\") label_length = label_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\") loss = self.loss_fn(y_true, y_pred, input_length, label_length) self.add_loss(loss) # At test time, just return the computed predictions return y_pred def build_model(): # Inputs to the model input_img = layers.Input( shape=(img_width, img_height, 1), name=\"image\", dtype=\"float32\" ) labels = layers.Input(name=\"label\", shape=(None,), dtype=\"float32\") # First conv block x = layers.Conv2D( 32, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\", name=\"Conv1\", )(input_img) x = layers.MaxPooling2D((2, 2), name=\"pool1\")(x) # Second conv block x = layers.Conv2D( 64, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\", name=\"Conv2\", )(x) x = layers.MaxPooling2D((2, 2), name=\"pool2\")(x) # We have used two max pool with pool size and strides 2. # Hence, downsampled feature maps are 4x smaller. The number of # filters in the last layer is 64. Reshape accordingly before # passing the output to the RNN part of the model new_shape = ((img_width // 4), (img_height // 4) * 64) x = layers.Reshape(target_shape=new_shape, name=\"reshape\")(x) x = layers.Dense(64, activation=\"relu\", name=\"dense1\")(x) x = layers.Dropout(0.2)(x) # RNNs x = layers.Bidirectional(layers.LSTM(128, return_sequences=True, dropout=0.25))(x) x = layers.Bidirectional(layers.LSTM(64, return_sequences=True, dropout=0.25))(x) # Output layer x = layers.Dense( len(char_to_num.get_vocabulary()) + 1, activation=\"softmax\", name=\"dense2\" )(x) # Add CTC layer for calculating CTC loss at each step output = CTCLayer(name=\"ctc_loss\")(labels, x) # Define the model model = keras.models.Model( inputs=[input_img, labels], outputs=output, name=\"ocr_model_v1\" ) # Optimizer opt = keras.optimizers.Adam() # Compile the model and return model.compile(optimizer=opt) return model # Get the model model = build_model() model.summary() Model: \"ocr_model_v1\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== image (InputLayer) [(None, 200, 50, 1)] 0 __________________________________________________________________________________________________ Conv1 (Conv2D) (None, 200, 50, 32) 320 image[0][0] __________________________________________________________________________________________________ pool1 (MaxPooling2D) (None, 100, 25, 32) 0 Conv1[0][0] __________________________________________________________________________________________________ Conv2 (Conv2D) (None, 100, 25, 64) 18496 pool1[0][0] __________________________________________________________________________________________________ pool2 (MaxPooling2D) (None, 50, 12, 64) 0 Conv2[0][0] __________________________________________________________________________________________________ reshape (Reshape) (None, 50, 768) 0 pool2[0][0] __________________________________________________________________________________________________ dense1 (Dense) (None, 50, 64) 49216 reshape[0][0] __________________________________________________________________________________________________ dropout (Dropout) (None, 50, 64) 0 dense1[0][0] __________________________________________________________________________________________________ bidirectional (Bidirectional) (None, 50, 256) 197632 dropout[0][0] __________________________________________________________________________________________________ bidirectional_1 (Bidirectional) (None, 50, 128) 164352 bidirectional[0][0] __________________________________________________________________________________________________ label (InputLayer) [(None, None)] 0 __________________________________________________________________________________________________ dense2 (Dense) (None, 50, 20) 2580 bidirectional_1[0][0] __________________________________________________________________________________________________ ctc_loss (CTCLayer) (None, 50, 20) 0 label[0][0] dense2[0][0] ================================================================================================== Total params: 432,596 Trainable params: 432,596 Non-trainable params: 0 __________________________________________________________________________________________________ Training epochs = 100 early_stopping_patience = 10 # Add early stopping early_stopping = keras.callbacks.EarlyStopping( monitor=\"val_loss\", patience=early_stopping_patience, restore_best_weights=True ) # Train the model history = model.fit( train_dataset, validation_data=validation_dataset, epochs=epochs, callbacks=[early_stopping], ) Epoch 1/100 59/59 [==============================] - 3s 53ms/step - loss: 21.5722 - val_loss: 16.3351 Epoch 2/100 59/59 [==============================] - 2s 27ms/step - loss: 16.3335 - val_loss: 16.3062 Epoch 3/100 59/59 [==============================] - 2s 27ms/step - loss: 16.3360 - val_loss: 16.3116 Epoch 4/100 59/59 [==============================] - 2s 27ms/step - loss: 16.3318 - val_loss: 16.3167 Epoch 5/100 59/59 [==============================] - 2s 27ms/step - loss: 16.3256 - val_loss: 16.3152 Epoch 6/100 59/59 [==============================] - 2s 29ms/step - loss: 16.3229 - val_loss: 16.3123 Epoch 7/100 59/59 [==============================] - 2s 30ms/step - loss: 16.3119 - val_loss: 16.3116 Epoch 8/100 59/59 [==============================] - 2s 27ms/step - loss: 16.2977 - val_loss: 16.3107 Epoch 9/100 59/59 [==============================] - 2s 28ms/step - loss: 16.2801 - val_loss: 16.2552 Epoch 10/100 59/59 [==============================] - 2s 28ms/step - loss: 16.2199 - val_loss: 16.1008 Epoch 11/100 59/59 [==============================] - 2s 28ms/step - loss: 16.1136 - val_loss: 15.9867 Epoch 12/100 59/59 [==============================] - 2s 30ms/step - loss: 16.0138 - val_loss: 15.8825 Epoch 13/100 59/59 [==============================] - 2s 29ms/step - loss: 15.9670 - val_loss: 15.8413 Epoch 14/100 59/59 [==============================] - 2s 29ms/step - loss: 15.9315 - val_loss: 15.8263 Epoch 15/100 59/59 [==============================] - 2s 31ms/step - loss: 15.9162 - val_loss: 15.7971 Epoch 16/100 59/59 [==============================] - 2s 31ms/step - loss: 15.8916 - val_loss: 15.7844 Epoch 17/100 59/59 [==============================] - 2s 31ms/step - loss: 15.8653 - val_loss: 15.7624 Epoch 18/100 59/59 [==============================] - 2s 31ms/step - loss: 15.8543 - val_loss: 15.7620 Epoch 19/100 59/59 [==============================] - 2s 28ms/step - loss: 15.8373 - val_loss: 15.7559 Epoch 20/100 59/59 [==============================] - 2s 27ms/step - loss: 15.8319 - val_loss: 15.7495 Epoch 21/100 59/59 [==============================] - 2s 27ms/step - loss: 15.8104 - val_loss: 15.7430 Epoch 22/100 59/59 [==============================] - 2s 29ms/step - loss: 15.8037 - val_loss: 15.7260 Epoch 23/100 59/59 [==============================] - 2s 29ms/step - loss: 15.8021 - val_loss: 15.7204 Epoch 24/100 59/59 [==============================] - 2s 28ms/step - loss: 15.7901 - val_loss: 15.7174 Epoch 25/100 59/59 [==============================] - 2s 29ms/step - loss: 15.7851 - val_loss: 15.7074 Epoch 26/100 59/59 [==============================] - 2s 27ms/step - loss: 15.7701 - val_loss: 15.7097 Epoch 27/100 59/59 [==============================] - 2s 28ms/step - loss: 15.7694 - val_loss: 15.7040 Epoch 28/100 59/59 [==============================] - 2s 28ms/step - loss: 15.7544 - val_loss: 15.7012 Epoch 29/100 59/59 [==============================] - 2s 31ms/step - loss: 15.7498 - val_loss: 15.7015 Epoch 30/100 59/59 [==============================] - 2s 31ms/step - loss: 15.7521 - val_loss: 15.6880 Epoch 31/100 59/59 [==============================] - 2s 29ms/step - loss: 15.7165 - val_loss: 15.6734 Epoch 32/100 59/59 [==============================] - 2s 27ms/step - loss: 15.6650 - val_loss: 15.5789 Epoch 33/100 59/59 [==============================] - 2s 27ms/step - loss: 15.5300 - val_loss: 15.4026 Epoch 34/100 59/59 [==============================] - 2s 27ms/step - loss: 15.3519 - val_loss: 15.2115 Epoch 35/100 59/59 [==============================] - 2s 27ms/step - loss: 15.1165 - val_loss: 14.7826 Epoch 36/100 59/59 [==============================] - 2s 27ms/step - loss: 14.7086 - val_loss: 14.4432 Epoch 37/100 59/59 [==============================] - 2s 29ms/step - loss: 14.3317 - val_loss: 13.9445 Epoch 38/100 59/59 [==============================] - 2s 29ms/step - loss: 13.9658 - val_loss: 13.6972 Epoch 39/100 59/59 [==============================] - 2s 29ms/step - loss: 13.6728 - val_loss: 13.3388 Epoch 40/100 59/59 [==============================] - 2s 28ms/step - loss: 13.3454 - val_loss: 13.0102 Epoch 41/100 59/59 [==============================] - 2s 27ms/step - loss: 13.0448 - val_loss: 12.8307 Epoch 42/100 59/59 [==============================] - 2s 28ms/step - loss: 12.7552 - val_loss: 12.6071 Epoch 43/100 59/59 [==============================] - 2s 29ms/step - loss: 12.4573 - val_loss: 12.2800 Epoch 44/100 59/59 [==============================] - 2s 31ms/step - loss: 12.1055 - val_loss: 11.9209 Epoch 45/100 59/59 [==============================] - 2s 28ms/step - loss: 11.8148 - val_loss: 11.9132 Epoch 46/100 59/59 [==============================] - 2s 28ms/step - loss: 11.4530 - val_loss: 11.4357 Epoch 47/100 59/59 [==============================] - 2s 29ms/step - loss: 11.0592 - val_loss: 11.1121 Epoch 48/100 59/59 [==============================] - 2s 27ms/step - loss: 10.7746 - val_loss: 10.8532 Epoch 49/100 59/59 [==============================] - 2s 28ms/step - loss: 10.2616 - val_loss: 10.3643 Epoch 50/100 59/59 [==============================] - 2s 28ms/step - loss: 9.8708 - val_loss: 10.0987 Epoch 51/100 59/59 [==============================] - 2s 30ms/step - loss: 9.4077 - val_loss: 9.6371 Epoch 52/100 59/59 [==============================] - 2s 29ms/step - loss: 9.0663 - val_loss: 9.2463 Epoch 53/100 59/59 [==============================] - 2s 28ms/step - loss: 8.4546 - val_loss: 8.7581 Epoch 54/100 59/59 [==============================] - 2s 28ms/step - loss: 7.9226 - val_loss: 8.1805 Epoch 55/100 59/59 [==============================] - 2s 27ms/step - loss: 7.4927 - val_loss: 7.8858 Epoch 56/100 59/59 [==============================] - 2s 28ms/step - loss: 7.0499 - val_loss: 7.3202 Epoch 57/100 59/59 [==============================] - 2s 27ms/step - loss: 6.6383 - val_loss: 7.0875 Epoch 58/100 59/59 [==============================] - 2s 28ms/step - loss: 6.1446 - val_loss: 6.9619 Epoch 59/100 59/59 [==============================] - 2s 28ms/step - loss: 5.8533 - val_loss: 6.3855 Epoch 60/100 59/59 [==============================] - 2s 28ms/step - loss: 5.5107 - val_loss: 5.9797 Epoch 61/100 59/59 [==============================] - 2s 31ms/step - loss: 5.1181 - val_loss: 5.7549 Epoch 62/100 59/59 [==============================] - 2s 31ms/step - loss: 4.6952 - val_loss: 5.5488 Epoch 63/100 59/59 [==============================] - 2s 29ms/step - loss: 4.4189 - val_loss: 5.3030 Epoch 64/100 59/59 [==============================] - 2s 28ms/step - loss: 4.1358 - val_loss: 5.1772 Epoch 65/100 59/59 [==============================] - 2s 28ms/step - loss: 3.8560 - val_loss: 5.1071 Epoch 66/100 59/59 [==============================] - 2s 28ms/step - loss: 3.5342 - val_loss: 4.6958 Epoch 67/100 59/59 [==============================] - 2s 28ms/step - loss: 3.3336 - val_loss: 4.5865 Epoch 68/100 59/59 [==============================] - 2s 27ms/step - loss: 3.0925 - val_loss: 4.3647 Epoch 69/100 59/59 [==============================] - 2s 28ms/step - loss: 2.8751 - val_loss: 4.3005 Epoch 70/100 59/59 [==============================] - 2s 27ms/step - loss: 2.7444 - val_loss: 4.0820 Epoch 71/100 59/59 [==============================] - 2s 27ms/step - loss: 2.5921 - val_loss: 4.1694 Epoch 72/100 59/59 [==============================] - 2s 28ms/step - loss: 2.3246 - val_loss: 3.9142 Epoch 73/100 59/59 [==============================] - 2s 28ms/step - loss: 2.0769 - val_loss: 3.9135 Epoch 74/100 59/59 [==============================] - 2s 29ms/step - loss: 2.0872 - val_loss: 3.9808 Epoch 75/100 59/59 [==============================] - 2s 29ms/step - loss: 1.9498 - val_loss: 3.9935 Epoch 76/100 59/59 [==============================] - 2s 28ms/step - loss: 1.8178 - val_loss: 3.7735 Epoch 77/100 59/59 [==============================] - 2s 29ms/step - loss: 1.7661 - val_loss: 3.6309 Epoch 78/100 59/59 [==============================] - 2s 31ms/step - loss: 1.6236 - val_loss: 3.7410 Epoch 79/100 59/59 [==============================] - 2s 29ms/step - loss: 1.4652 - val_loss: 3.6756 Epoch 80/100 59/59 [==============================] - 2s 27ms/step - loss: 1.3552 - val_loss: 3.4979 Epoch 81/100 59/59 [==============================] - 2s 29ms/step - loss: 1.2655 - val_loss: 3.5306 Epoch 82/100 59/59 [==============================] - 2s 29ms/step - loss: 1.2632 - val_loss: 3.2885 Epoch 83/100 59/59 [==============================] - 2s 28ms/step - loss: 1.2316 - val_loss: 3.2482 Epoch 84/100 59/59 [==============================] - 2s 30ms/step - loss: 1.1260 - val_loss: 3.4285 Epoch 85/100 59/59 [==============================] - 2s 28ms/step - loss: 1.0745 - val_loss: 3.2985 Epoch 86/100 59/59 [==============================] - 2s 29ms/step - loss: 1.0133 - val_loss: 3.2209 Epoch 87/100 59/59 [==============================] - 2s 31ms/step - loss: 0.9417 - val_loss: 3.2203 Epoch 88/100 59/59 [==============================] - 2s 28ms/step - loss: 0.9104 - val_loss: 3.1121 Epoch 89/100 59/59 [==============================] - 2s 30ms/step - loss: 0.8516 - val_loss: 3.2070 Epoch 90/100 59/59 [==============================] - 2s 28ms/step - loss: 0.8275 - val_loss: 3.0335 Epoch 91/100 59/59 [==============================] - 2s 28ms/step - loss: 0.8056 - val_loss: 3.2085 Epoch 92/100 59/59 [==============================] - 2s 28ms/step - loss: 0.7373 - val_loss: 3.0326 Epoch 93/100 59/59 [==============================] - 2s 28ms/step - loss: 0.7753 - val_loss: 2.9935 Epoch 94/100 59/59 [==============================] - 2s 28ms/step - loss: 0.7688 - val_loss: 2.9940 Epoch 95/100 59/59 [==============================] - 2s 27ms/step - loss: 0.6765 - val_loss: 3.0432 Epoch 96/100 59/59 [==============================] - 2s 29ms/step - loss: 0.6674 - val_loss: 3.1233 Epoch 97/100 59/59 [==============================] - 2s 29ms/step - loss: 0.6018 - val_loss: 2.8405 Epoch 98/100 59/59 [==============================] - 2s 28ms/step - loss: 0.6322 - val_loss: 2.8323 Epoch 99/100 59/59 [==============================] - 2s 29ms/step - loss: 0.5889 - val_loss: 2.8786 Epoch 100/100 59/59 [==============================] - 2s 28ms/step - loss: 0.5616 - val_loss: 2.9697 Inference # Get the prediction model by extracting layers till the output layer prediction_model = keras.models.Model( model.get_layer(name=\"image\").input, model.get_layer(name=\"dense2\").output ) prediction_model.summary() # A utility function to decode the output of the network def decode_batch_predictions(pred): input_len = np.ones(pred.shape[0]) * pred.shape[1] # Use greedy search. For complex tasks, you can use beam search results = keras.backend.ctc_decode(pred, input_length=input_len, greedy=True)[0][0][ :, :max_length ] # Iterate over the results and get back the text output_text = [] for res in results: res = tf.strings.reduce_join(num_to_char(res)).numpy().decode(\"utf-8\") output_text.append(res) return output_text # Let's check results on some validation samples for batch in validation_dataset.take(1): batch_images = batch[\"image\"] batch_labels = batch[\"label\"] preds = prediction_model.predict(batch_images) pred_texts = decode_batch_predictions(preds) orig_texts = [] for label in batch_labels: label = tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\") orig_texts.append(label) _, ax = plt.subplots(4, 4, figsize=(15, 5)) for i in range(len(pred_texts)): img = (batch_images[i, :, :, 0] * 255).numpy().astype(np.uint8) img = img.T title = f\"Prediction: {pred_texts[i]}\" ax[i // 4, i % 4].imshow(img, cmap=\"gray\") ax[i // 4, i % 4].set_title(title) ax[i // 4, i % 4].axis(\"off\") plt.show() Model: \"functional_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= image (InputLayer) [(None, 200, 50, 1)] 0 _________________________________________________________________ Conv1 (Conv2D) (None, 200, 50, 32) 320 _________________________________________________________________ pool1 (MaxPooling2D) (None, 100, 25, 32) 0 _________________________________________________________________ Conv2 (Conv2D) (None, 100, 25, 64) 18496 _________________________________________________________________ pool2 (MaxPooling2D) (None, 50, 12, 64) 0 _________________________________________________________________ reshape (Reshape) (None, 50, 768) 0 _________________________________________________________________ dense1 (Dense) (None, 50, 64) 49216 _________________________________________________________________ dropout (Dropout) (None, 50, 64) 0 _________________________________________________________________ bidirectional (Bidirectional (None, 50, 256) 197632 _________________________________________________________________ bidirectional_1 (Bidirection (None, 50, 128) 164352 _________________________________________________________________ dense2 (Dense) (None, 50, 20) 2580 ================================================================= Total params: 432,596 Trainable params: 432,596 Non-trainable params: 0 _________________________________________________________________ png Medical image classification on TPU. Introduction + Set-up This tutorial will explain how to build an X-ray image classification model to predict whether an X-ray scan shows presence of pneumonia. import re import os import random import numpy as np import pandas as pd import tensorflow as tf import matplotlib.pyplot as plt try: tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect() print(\"Device:\", tpu.master()) strategy = tf.distribute.TPUStrategy(tpu) except: strategy = tf.distribute.get_strategy() print(\"Number of replicas:\", strategy.num_replicas_in_sync) Device: grpc://10.0.27.122:8470 INFO:tensorflow:Initializing the TPU system: grpc://10.0.27.122:8470 INFO:tensorflow:Initializing the TPU system: grpc://10.0.27.122:8470 INFO:tensorflow:Clearing out eager caches INFO:tensorflow:Clearing out eager caches INFO:tensorflow:Finished initializing TPU system. INFO:tensorflow:Finished initializing TPU system. WARNING:absl:[`tf.distribute.TPUStrategy`](https://www.tensorflow.org/api_docs/python/tf/distribute/TPUStrategy) is deprecated, please use the non experimental symbol [`tf.distribute.TPUStrategy`](https://www.tensorflow.org/api_docs/python/tf/distribute/TPUStrategy) instead. INFO:tensorflow:Found TPU system: INFO:tensorflow:Found TPU system: INFO:tensorflow:*** Num TPU Cores: 8 INFO:tensorflow:*** Num TPU Cores: 8 INFO:tensorflow:*** Num TPU Workers: 1 INFO:tensorflow:*** Num TPU Workers: 1 INFO:tensorflow:*** Num TPU Cores Per Worker: 8 INFO:tensorflow:*** Num TPU Cores Per Worker: 8 INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) Number of replicas: 8 We need a Google Cloud link to our data to load the data using a TPU. Below, we define key configuration parameters we'll use in this example. To run on TPU, this example must be on Colab with the TPU runtime selected. AUTOTUNE = tf.data.AUTOTUNE BATCH_SIZE = 25 * strategy.num_replicas_in_sync IMAGE_SIZE = [180, 180] CLASS_NAMES = [\"NORMAL\", \"PNEUMONIA\"] Load the data The Chest X-ray data we are using from Cell divides the data into training and test files. Let's first load in the training TFRecords. train_images = tf.data.TFRecordDataset( \"gs://download.tensorflow.org/data/ChestXRay2017/train/images.tfrec\" ) train_paths = tf.data.TFRecordDataset( \"gs://download.tensorflow.org/data/ChestXRay2017/train/paths.tfrec\" ) ds = tf.data.Dataset.zip((train_images, train_paths)) Let's count how many healthy/normal chest X-rays we have and how many pneumonia chest X-rays we have: COUNT_NORMAL = len( [ filename for filename in train_paths if \"NORMAL\" in filename.numpy().decode(\"utf-8\") ] ) print(\"Normal images count in training set: \" + str(COUNT_NORMAL)) COUNT_PNEUMONIA = len( [ filename for filename in train_paths if \"PNEUMONIA\" in filename.numpy().decode(\"utf-8\") ] ) print(\"Pneumonia images count in training set: \" + str(COUNT_PNEUMONIA)) Normal images count in training set: 1349 Pneumonia images count in training set: 3883 Notice that there are way more images that are classified as pneumonia than normal. This shows that we have an imbalance in our data. We will correct for this imbalance later on in our notebook. We want to map each filename to the corresponding (image, label) pair. The following methods will help us do that. As we only have two labels, we will encode the label so that 1 or True indicates pneumonia and 0 or False indicates normal. def get_label(file_path): # convert the path to a list of path components parts = tf.strings.split(file_path, \"/\") # The second to last is the class-directory return parts[-2] == \"PNEUMONIA\" def decode_img(img): # convert the compressed string to a 3D uint8 tensor img = tf.image.decode_jpeg(img, channels=3) # resize the image to the desired size. return tf.image.resize(img, IMAGE_SIZE) def process_path(image, path): label = get_label(path) # load the raw data from the file as a string img = decode_img(image) return img, label ds = ds.map(process_path, num_parallel_calls=AUTOTUNE) Let's split the data into a training and validation datasets. ds = ds.shuffle(10000) train_ds = ds.take(4200) val_ds = ds.skip(4200) Let's visualize the shape of an (image, label) pair. for image, label in train_ds.take(1): print(\"Image shape: \", image.numpy().shape) print(\"Label: \", label.numpy()) Image shape: (180, 180, 3) Label: False Load and format the test data as well. test_images = tf.data.TFRecordDataset( \"gs://download.tensorflow.org/data/ChestXRay2017/test/images.tfrec\" ) test_paths = tf.data.TFRecordDataset( \"gs://download.tensorflow.org/data/ChestXRay2017/test/paths.tfrec\" ) test_ds = tf.data.Dataset.zip((test_images, test_paths)) test_ds = test_ds.map(process_path, num_parallel_calls=AUTOTUNE) test_ds = test_ds.batch(BATCH_SIZE) Visualize the dataset First, let's use buffered prefetching so we can yield data from disk without having I/O become blocking. Please note that large image datasets should not be cached in memory. We do it here because the dataset is not very large and we want to train on TPU. def prepare_for_training(ds, cache=True): # This is a small dataset, only load it once, and keep it in memory. # use `.cache(filename)` to cache preprocessing work for datasets that don't # fit in memory. if cache: if isinstance(cache, str): ds = ds.cache(cache) else: ds = ds.cache() ds = ds.batch(BATCH_SIZE) # `prefetch` lets the dataset fetch batches in the background while the model # is training. ds = ds.prefetch(buffer_size=AUTOTUNE) return ds Call the next batch iteration of the training data. train_ds = prepare_for_training(train_ds) val_ds = prepare_for_training(val_ds) image_batch, label_batch = next(iter(train_ds)) Define the method to show the images in the batch. def show_batch(image_batch, label_batch): plt.figure(figsize=(10, 10)) for n in range(25): ax = plt.subplot(5, 5, n + 1) plt.imshow(image_batch[n] / 255) if label_batch[n]: plt.title(\"PNEUMONIA\") else: plt.title(\"NORMAL\") plt.axis(\"off\") As the method takes in NumPy arrays as its parameters, call the numpy function on the batches to return the tensor in NumPy array form. show_batch(image_batch.numpy(), label_batch.numpy()) png Build the CNN To make our model more modular and easier to understand, let's define some blocks. As we're building a convolution neural network, we'll create a convolution block and a dense layer block. The architecture for this CNN has been inspired by this article. from tensorflow import keras from tensorflow.keras import layers def conv_block(filters, inputs): x = layers.SeparableConv2D(filters, 3, activation=\"relu\", padding=\"same\")(inputs) x = layers.SeparableConv2D(filters, 3, activation=\"relu\", padding=\"same\")(x) x = layers.BatchNormalization()(x) outputs = layers.MaxPool2D()(x) return outputs def dense_block(units, dropout_rate, inputs): x = layers.Dense(units, activation=\"relu\")(inputs) x = layers.BatchNormalization()(x) outputs = layers.Dropout(dropout_rate)(x) return outputs The following method will define the function to build our model for us. The images originally have values that range from [0, 255]. CNNs work better with smaller numbers so we will scale this down for our input. The Dropout layers are important, as they reduce the likelikhood of the model overfitting. We want to end the model with a Dense layer with one node, as this will be the binary output that determines if an X-ray shows presence of pneumonia. def build_model(): inputs = keras.Input(shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3)) x = layers.Rescaling(1.0 / 255)(inputs) x = layers.Conv2D(16, 3, activation=\"relu\", padding=\"same\")(x) x = layers.Conv2D(16, 3, activation=\"relu\", padding=\"same\")(x) x = layers.MaxPool2D()(x) x = conv_block(32, x) x = conv_block(64, x) x = conv_block(128, x) x = layers.Dropout(0.2)(x) x = conv_block(256, x) x = layers.Dropout(0.2)(x) x = layers.Flatten()(x) x = dense_block(512, 0.7, x) x = dense_block(128, 0.5, x) x = dense_block(64, 0.3, x) outputs = layers.Dense(1, activation=\"sigmoid\")(x) model = keras.Model(inputs=inputs, outputs=outputs) return model Correct for data imbalance We saw earlier in this example that the data was imbalanced, with more images classified as pneumonia than normal. We will correct for that by using class weighting: initial_bias = np.log([COUNT_PNEUMONIA / COUNT_NORMAL]) print(\"Initial bias: {:.5f}\".format(initial_bias[0])) TRAIN_IMG_COUNT = COUNT_NORMAL + COUNT_PNEUMONIA weight_for_0 = (1 / COUNT_NORMAL) * (TRAIN_IMG_COUNT) / 2.0 weight_for_1 = (1 / COUNT_PNEUMONIA) * (TRAIN_IMG_COUNT) / 2.0 class_weight = {0: weight_for_0, 1: weight_for_1} print(\"Weight for class 0: {:.2f}\".format(weight_for_0)) print(\"Weight for class 1: {:.2f}\".format(weight_for_1)) Initial bias: 1.05724 Weight for class 0: 1.94 Weight for class 1: 0.67 The weight for class 0 (Normal) is a lot higher than the weight for class 1 (Pneumonia). Because there are less normal images, each normal image will be weighted more to balance the data as the CNN works best when the training data is balanced. Train the model Defining callbacks The checkpoint callback saves the best weights of the model, so next time we want to use the model, we do not have to spend time training it. The early stopping callback stops the training process when the model starts becoming stagnant, or even worse, when the model starts overfitting. checkpoint_cb = tf.keras.callbacks.ModelCheckpoint(\"xray_model.h5\", save_best_only=True) early_stopping_cb = tf.keras.callbacks.EarlyStopping( patience=10, restore_best_weights=True ) We also want to tune our learning rate. Too high of a learning rate will cause the model to diverge. Too small of a learning rate will cause the model to be too slow. We implement the exponential learning rate scheduling method below. initial_learning_rate = 0.015 lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay( initial_learning_rate, decay_steps=100000, decay_rate=0.96, staircase=True ) Fit the model For our metrics, we want to include precision and recall as they will provide use with a more informed picture of how good our model is. Accuracy tells us what fraction of the labels is correct. Since our data is not balanced, accuracy might give a skewed sense of a good model (i.e. a model that always predicts PNEUMONIA will be 74% accurate but is not a good model). Precision is the number of true positives (TP) over the sum of TP and false positives (FP). It shows what fraction of labeled positives are actually correct. Recall is the number of TP over the sum of TP and false negatves (FN). It shows what fraction of actual positives are correct. Since there are only two possible labels for the image, we will be using the binary crossentropy loss. When we fit the model, remember to specify the class weights, which we defined earlier. Because we are using a TPU, training will be quick - less than 2 minutes. with strategy.scope(): model = build_model() METRICS = [ tf.keras.metrics.BinaryAccuracy(), tf.keras.metrics.Precision(name=\"precision\"), tf.keras.metrics.Recall(name=\"recall\"), ] model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=lr_schedule), loss=\"binary_crossentropy\", metrics=METRICS, ) history = model.fit( train_ds, epochs=100, validation_data=val_ds, class_weight=class_weight, callbacks=[checkpoint_cb, early_stopping_cb], ) Epoch 1/100 WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version. Instructions for updating: Use `tf.data.Iterator.get_next_as_optional()` instead. WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version. Instructions for updating: Use `tf.data.Iterator.get_next_as_optional()` instead. 21/21 [==============================] - 12s 568ms/step - loss: 0.5857 - binary_accuracy: 0.6960 - precision: 0.8887 - recall: 0.6733 - val_loss: 34.0149 - val_binary_accuracy: 0.7180 - val_precision: 0.7180 - val_recall: 1.0000 Epoch 2/100 21/21 [==============================] - 3s 128ms/step - loss: 0.2916 - binary_accuracy: 0.8755 - precision: 0.9540 - recall: 0.8738 - val_loss: 97.5194 - val_binary_accuracy: 0.7180 - val_precision: 0.7180 - val_recall: 1.0000 Epoch 3/100 21/21 [==============================] - 4s 167ms/step - loss: 0.2384 - binary_accuracy: 0.9002 - precision: 0.9663 - recall: 0.8964 - val_loss: 27.7902 - val_binary_accuracy: 0.7180 - val_precision: 0.7180 - val_recall: 1.0000 Epoch 4/100 21/21 [==============================] - 4s 173ms/step - loss: 0.2046 - binary_accuracy: 0.9145 - precision: 0.9725 - recall: 0.9102 - val_loss: 10.8302 - val_binary_accuracy: 0.7180 - val_precision: 0.7180 - val_recall: 1.0000 Epoch 5/100 21/21 [==============================] - 4s 174ms/step - loss: 0.1841 - binary_accuracy: 0.9279 - precision: 0.9733 - recall: 0.9279 - val_loss: 3.5860 - val_binary_accuracy: 0.7103 - val_precision: 0.7162 - val_recall: 0.9879 Epoch 6/100 21/21 [==============================] - 4s 185ms/step - loss: 0.1600 - binary_accuracy: 0.9362 - precision: 0.9791 - recall: 0.9337 - val_loss: 0.3014 - val_binary_accuracy: 0.8895 - val_precision: 0.8973 - val_recall: 0.9555 Epoch 7/100 21/21 [==============================] - 3s 130ms/step - loss: 0.1567 - binary_accuracy: 0.9393 - precision: 0.9798 - recall: 0.9372 - val_loss: 0.6763 - val_binary_accuracy: 0.7810 - val_precision: 0.7760 - val_recall: 0.9771 Epoch 8/100 21/21 [==============================] - 3s 131ms/step - loss: 0.1532 - binary_accuracy: 0.9421 - precision: 0.9825 - recall: 0.9385 - val_loss: 0.3169 - val_binary_accuracy: 0.8895 - val_precision: 0.8684 - val_recall: 0.9973 Epoch 9/100 21/21 [==============================] - 4s 184ms/step - loss: 0.1457 - binary_accuracy: 0.9431 - precision: 0.9822 - recall: 0.9401 - val_loss: 0.2064 - val_binary_accuracy: 0.9273 - val_precision: 0.9840 - val_recall: 0.9136 Epoch 10/100 21/21 [==============================] - 3s 132ms/step - loss: 0.1201 - binary_accuracy: 0.9521 - precision: 0.9869 - recall: 0.9479 - val_loss: 0.4364 - val_binary_accuracy: 0.8605 - val_precision: 0.8443 - val_recall: 0.9879 Epoch 11/100 21/21 [==============================] - 3s 127ms/step - loss: 0.1200 - binary_accuracy: 0.9510 - precision: 0.9863 - recall: 0.9469 - val_loss: 0.5197 - val_binary_accuracy: 0.8508 - val_precision: 1.0000 - val_recall: 0.7922 Epoch 12/100 21/21 [==============================] - 4s 186ms/step - loss: 0.1077 - binary_accuracy: 0.9581 - precision: 0.9870 - recall: 0.9559 - val_loss: 0.1349 - val_binary_accuracy: 0.9486 - val_precision: 0.9587 - val_recall: 0.9703 Epoch 13/100 21/21 [==============================] - 4s 173ms/step - loss: 0.0918 - binary_accuracy: 0.9650 - precision: 0.9914 - recall: 0.9611 - val_loss: 0.0926 - val_binary_accuracy: 0.9700 - val_precision: 0.9837 - val_recall: 0.9744 Epoch 14/100 21/21 [==============================] - 3s 130ms/step - loss: 0.0996 - binary_accuracy: 0.9612 - precision: 0.9913 - recall: 0.9559 - val_loss: 0.1811 - val_binary_accuracy: 0.9419 - val_precision: 0.9956 - val_recall: 0.9231 Epoch 15/100 21/21 [==============================] - 3s 129ms/step - loss: 0.0898 - binary_accuracy: 0.9643 - precision: 0.9901 - recall: 0.9614 - val_loss: 0.1525 - val_binary_accuracy: 0.9486 - val_precision: 0.9986 - val_recall: 0.9298 Epoch 16/100 21/21 [==============================] - 3s 128ms/step - loss: 0.0941 - binary_accuracy: 0.9621 - precision: 0.9904 - recall: 0.9582 - val_loss: 0.5101 - val_binary_accuracy: 0.8527 - val_precision: 1.0000 - val_recall: 0.7949 Epoch 17/100 21/21 [==============================] - 3s 125ms/step - loss: 0.0798 - binary_accuracy: 0.9636 - precision: 0.9897 - recall: 0.9607 - val_loss: 0.1239 - val_binary_accuracy: 0.9622 - val_precision: 0.9875 - val_recall: 0.9595 Epoch 18/100 21/21 [==============================] - 3s 126ms/step - loss: 0.0821 - binary_accuracy: 0.9657 - precision: 0.9911 - recall: 0.9623 - val_loss: 0.1597 - val_binary_accuracy: 0.9322 - val_precision: 0.9956 - val_recall: 0.9096 Epoch 19/100 21/21 [==============================] - 3s 143ms/step - loss: 0.0800 - binary_accuracy: 0.9657 - precision: 0.9917 - recall: 0.9617 - val_loss: 0.2538 - val_binary_accuracy: 0.9109 - val_precision: 1.0000 - val_recall: 0.8758 Epoch 20/100 21/21 [==============================] - 3s 127ms/step - loss: 0.0605 - binary_accuracy: 0.9738 - precision: 0.9950 - recall: 0.9694 - val_loss: 0.6594 - val_binary_accuracy: 0.8566 - val_precision: 1.0000 - val_recall: 0.8003 Epoch 21/100 21/21 [==============================] - 4s 167ms/step - loss: 0.0726 - binary_accuracy: 0.9733 - precision: 0.9937 - recall: 0.9701 - val_loss: 0.0593 - val_binary_accuracy: 0.9816 - val_precision: 0.9945 - val_recall: 0.9798 Epoch 22/100 21/21 [==============================] - 3s 126ms/step - loss: 0.0577 - binary_accuracy: 0.9783 - precision: 0.9951 - recall: 0.9755 - val_loss: 0.1087 - val_binary_accuracy: 0.9729 - val_precision: 0.9931 - val_recall: 0.9690 Epoch 23/100 21/21 [==============================] - 3s 125ms/step - loss: 0.0652 - binary_accuracy: 0.9729 - precision: 0.9924 - recall: 0.9707 - val_loss: 1.8465 - val_binary_accuracy: 0.7180 - val_precision: 0.7180 - val_recall: 1.0000 Epoch 24/100 21/21 [==============================] - 3s 124ms/step - loss: 0.0538 - binary_accuracy: 0.9783 - precision: 0.9951 - recall: 0.9755 - val_loss: 1.5769 - val_binary_accuracy: 0.7180 - val_precision: 0.7180 - val_recall: 1.0000 Epoch 25/100 21/21 [==============================] - 4s 167ms/step - loss: 0.0549 - binary_accuracy: 0.9776 - precision: 0.9954 - recall: 0.9743 - val_loss: 0.0590 - val_binary_accuracy: 0.9777 - val_precision: 0.9904 - val_recall: 0.9784 Epoch 26/100 21/21 [==============================] - 3s 131ms/step - loss: 0.0677 - binary_accuracy: 0.9719 - precision: 0.9924 - recall: 0.9694 - val_loss: 2.6008 - val_binary_accuracy: 0.6928 - val_precision: 0.9977 - val_recall: 0.5735 Epoch 27/100 21/21 [==============================] - 3s 127ms/step - loss: 0.0469 - binary_accuracy: 0.9833 - precision: 0.9971 - recall: 0.9804 - val_loss: 1.0184 - val_binary_accuracy: 0.8605 - val_precision: 0.9983 - val_recall: 0.8070 Epoch 28/100 21/21 [==============================] - 3s 126ms/step - loss: 0.0501 - binary_accuracy: 0.9790 - precision: 0.9961 - recall: 0.9755 - val_loss: 0.3737 - val_binary_accuracy: 0.9089 - val_precision: 0.9954 - val_recall: 0.8772 Epoch 29/100 21/21 [==============================] - 3s 128ms/step - loss: 0.0548 - binary_accuracy: 0.9798 - precision: 0.9941 - recall: 0.9784 - val_loss: 1.2928 - val_binary_accuracy: 0.7907 - val_precision: 1.0000 - val_recall: 0.7085 Epoch 30/100 21/21 [==============================] - 3s 129ms/step - loss: 0.0370 - binary_accuracy: 0.9860 - precision: 0.9980 - recall: 0.9829 - val_loss: 0.1370 - val_binary_accuracy: 0.9612 - val_precision: 0.9972 - val_recall: 0.9487 Epoch 31/100 21/21 [==============================] - 3s 125ms/step - loss: 0.0585 - binary_accuracy: 0.9819 - precision: 0.9951 - recall: 0.9804 - val_loss: 1.1955 - val_binary_accuracy: 0.6870 - val_precision: 0.9976 - val_recall: 0.5655 Epoch 32/100 21/21 [==============================] - 3s 140ms/step - loss: 0.0813 - binary_accuracy: 0.9695 - precision: 0.9934 - recall: 0.9652 - val_loss: 1.0394 - val_binary_accuracy: 0.8576 - val_precision: 0.9853 - val_recall: 0.8138 Epoch 33/100 21/21 [==============================] - 3s 128ms/step - loss: 0.1111 - binary_accuracy: 0.9555 - precision: 0.9870 - recall: 0.9524 - val_loss: 4.9438 - val_binary_accuracy: 0.5911 - val_precision: 1.0000 - val_recall: 0.4305 Epoch 34/100 21/21 [==============================] - 3s 130ms/step - loss: 0.0680 - binary_accuracy: 0.9726 - precision: 0.9921 - recall: 0.9707 - val_loss: 2.8822 - val_binary_accuracy: 0.7267 - val_precision: 0.9978 - val_recall: 0.6208 Epoch 35/100 21/21 [==============================] - 4s 187ms/step - loss: 0.0784 - binary_accuracy: 0.9712 - precision: 0.9892 - recall: 0.9717 - val_loss: 0.3940 - val_binary_accuracy: 0.9390 - val_precision: 0.9942 - val_recall: 0.9204 Visualizing model performance Let's plot the model accuracy and loss for the training and the validating set. Note that no random seed is specified for this notebook. For your notebook, there might be slight variance. fig, ax = plt.subplots(1, 4, figsize=(20, 3)) ax = ax.ravel() for i, met in enumerate([\"precision\", \"recall\", \"binary_accuracy\", \"loss\"]): ax[i].plot(history.history[met]) ax[i].plot(history.history[\"val_\" + met]) ax[i].set_title(\"Model {}\".format(met)) ax[i].set_xlabel(\"epochs\") ax[i].set_ylabel(met) ax[i].legend([\"train\", \"val\"]) png We see that the accuracy for our model is around 95%. Predict and evaluate results Let's evaluate the model on our test data! model.evaluate(test_ds, return_dict=True) 4/4 [==============================] - 3s 708ms/step - loss: 0.9718 - binary_accuracy: 0.7901 - precision: 0.7524 - recall: 0.9897 {'binary_accuracy': 0.7900640964508057, 'loss': 0.9717951416969299, 'precision': 0.752436637878418, 'recall': 0.9897436499595642} We see that our accuracy on our test data is lower than the accuracy for our validating set. This may indicate overfitting. Our recall is greater than our precision, indicating that almost all pneumonia images are correctly identified but some normal images are falsely identified. We should aim to increase our precision. for image, label in test_ds.take(1): plt.imshow(image[0] / 255.0) plt.title(CLASS_NAMES[label[0].numpy()]) prediction = model.predict(test_ds.take(1))[0] scores = [1 - prediction, prediction] for score, name in zip(scores, CLASS_NAMES): print(\"This image is %.2f percent %s\" % ((100 * score), name)) /usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:3: DeprecationWarning: In future, it will be an error for 'np.bool_' scalars to be interpreted as an index This is separate from the ipykernel package so we can avoid doing imports until This image is 47.19 percent NORMAL This image is 52.81 percent PNEUMONIA png Implementation of PointNet for ModelNet10 classification. Introduction Classification, detection and segmentation of unordered 3D point sets i.e. point clouds is a core problem in computer vision. This example implements the seminal point cloud deep learning paper PointNet (Qi et al., 2017). For a detailed intoduction on PointNet see this blog post. Setup If using colab first install trimesh with !pip install trimesh. import os import glob import trimesh import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from matplotlib import pyplot as plt tf.random.set_seed(1234) Load dataset We use the ModelNet10 model dataset, the smaller 10 class version of the ModelNet40 dataset. First download the data: DATA_DIR = tf.keras.utils.get_file( \"modelnet.zip\", \"http://3dvision.princeton.edu/projects/2014/3DShapeNets/ModelNet10.zip\", extract=True, ) DATA_DIR = os.path.join(os.path.dirname(DATA_DIR), \"ModelNet10\") Downloading data from http://3dvision.princeton.edu/projects/2014/3DShapeNets/ModelNet10.zip 473407488/473402300 [==============================] - 13s 0us/step We can use the trimesh package to read and visualize the .off mesh files. mesh = trimesh.load(os.path.join(DATA_DIR, \"chair/train/chair_0001.off\")) mesh.show() To convert a mesh file to a point cloud we first need to sample points on the mesh surface. .sample() performs a unifrom random sampling. Here we sample at 2048 locations and visualize in matplotlib. points = mesh.sample(2048) fig = plt.figure(figsize=(5, 5)) ax = fig.add_subplot(111, projection=\"3d\") ax.scatter(points[:, 0], points[:, 1], points[:, 2]) ax.set_axis_off() plt.show() png To generate a tf.data.Dataset() we need to first parse through the ModelNet data folders. Each mesh is loaded and sampled into a point cloud before being added to a standard python list and converted to a numpy array. We also store the current enumerate index value as the object label and use a dictionary to recall this later. def parse_dataset(num_points=2048): train_points = [] train_labels = [] test_points = [] test_labels = [] class_map = {} folders = glob.glob(os.path.join(DATA_DIR, \"[!README]*\")) for i, folder in enumerate(folders): print(\"processing class: {}\".format(os.path.basename(folder))) # store folder name with ID so we can retrieve later class_map[i] = folder.split(\"/\")[-1] # gather all files train_files = glob.glob(os.path.join(folder, \"train/*\")) test_files = glob.glob(os.path.join(folder, \"test/*\")) for f in train_files: train_points.append(trimesh.load(f).sample(num_points)) train_labels.append(i) for f in test_files: test_points.append(trimesh.load(f).sample(num_points)) test_labels.append(i) return ( np.array(train_points), np.array(test_points), np.array(train_labels), np.array(test_labels), class_map, ) Set the number of points to sample and batch size and parse the dataset. This can take ~5minutes to complete. NUM_POINTS = 2048 NUM_CLASSES = 10 BATCH_SIZE = 32 train_points, test_points, train_labels, test_labels, CLASS_MAP = parse_dataset( NUM_POINTS ) processing class: bathtub processing class: desk processing class: monitor processing class: sofa processing class: chair processing class: toilet processing class: dresser processing class: table processing class: bed processing class: night_stand Our data can now be read into a tf.data.Dataset() object. We set the shuffle buffer size to the entire size of the dataset as prior to this the data is ordered by class. Data augmentation is important when working with point cloud data. We create a augmentation function to jitter and shuffle the train dataset. def augment(points, label): # jitter points points += tf.random.uniform(points.shape, -0.005, 0.005, dtype=tf.float64) # shuffle points points = tf.random.shuffle(points) return points, label train_dataset = tf.data.Dataset.from_tensor_slices((train_points, train_labels)) test_dataset = tf.data.Dataset.from_tensor_slices((test_points, test_labels)) train_dataset = train_dataset.shuffle(len(train_points)).map(augment).batch(BATCH_SIZE) test_dataset = test_dataset.shuffle(len(test_points)).batch(BATCH_SIZE) Build a model Each convolution and fully-connected layer (with exception for end layers) consits of Convolution / Dense -> Batch Normalization -> ReLU Activation. def conv_bn(x, filters): x = layers.Conv1D(filters, kernel_size=1, padding=\"valid\")(x) x = layers.BatchNormalization(momentum=0.0)(x) return layers.Activation(\"relu\")(x) def dense_bn(x, filters): x = layers.Dense(filters)(x) x = layers.BatchNormalization(momentum=0.0)(x) return layers.Activation(\"relu\")(x) PointNet consists of two core components. The primary MLP network, and the transformer net (T-net). The T-net aims to learn an affine transformation matrix by its own mini network. The T-net is used twice. The first time to transform the input features (n, 3) into a canonical representation. The second is an affine transformation for alignment in feature space (n, 3). As per the original paper we constrain the transformation to be close to an orthogonal matrix (i.e. ||X*X^T - I|| = 0). class OrthogonalRegularizer(keras.regularizers.Regularizer): def __init__(self, num_features, l2reg=0.001): self.num_features = num_features self.l2reg = l2reg self.eye = tf.eye(num_features) def __call__(self, x): x = tf.reshape(x, (-1, self.num_features, self.num_features)) xxt = tf.tensordot(x, x, axes=(2, 2)) xxt = tf.reshape(xxt, (-1, self.num_features, self.num_features)) return tf.reduce_sum(self.l2reg * tf.square(xxt - self.eye)) We can then define a general function to build T-net layers. def tnet(inputs, num_features): # Initalise bias as the indentity matrix bias = keras.initializers.Constant(np.eye(num_features).flatten()) reg = OrthogonalRegularizer(num_features) x = conv_bn(inputs, 32) x = conv_bn(x, 64) x = conv_bn(x, 512) x = layers.GlobalMaxPooling1D()(x) x = dense_bn(x, 256) x = dense_bn(x, 128) x = layers.Dense( num_features * num_features, kernel_initializer=\"zeros\", bias_initializer=bias, activity_regularizer=reg, )(x) feat_T = layers.Reshape((num_features, num_features))(x) # Apply affine transformation to input features return layers.Dot(axes=(2, 1))([inputs, feat_T]) The main network can be then implemented in the same manner where the t-net mini models can be dropped in a layers in the graph. Here we replicate the network architecture published in the original paper but with half the number of weights at each layer as we are using the smaller 10 class ModelNet dataset. inputs = keras.Input(shape=(NUM_POINTS, 3)) x = tnet(inputs, 3) x = conv_bn(x, 32) x = conv_bn(x, 32) x = tnet(x, 32) x = conv_bn(x, 32) x = conv_bn(x, 64) x = conv_bn(x, 512) x = layers.GlobalMaxPooling1D()(x) x = dense_bn(x, 256) x = layers.Dropout(0.3)(x) x = dense_bn(x, 128) x = layers.Dropout(0.3)(x) outputs = layers.Dense(NUM_CLASSES, activation=\"softmax\")(x) model = keras.Model(inputs=inputs, outputs=outputs, name=\"pointnet\") model.summary() Model: \"pointnet\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 2048, 3)] 0 __________________________________________________________________________________________________ conv1d (Conv1D) (None, 2048, 32) 128 input_1[0][0] __________________________________________________________________________________________________ batch_normalization (BatchNorma (None, 2048, 32) 128 conv1d[0][0] __________________________________________________________________________________________________ activation (Activation) (None, 2048, 32) 0 batch_normalization[0][0] __________________________________________________________________________________________________ conv1d_1 (Conv1D) (None, 2048, 64) 2112 activation[0][0] __________________________________________________________________________________________________ batch_normalization_1 (BatchNor (None, 2048, 64) 256 conv1d_1[0][0] __________________________________________________________________________________________________ activation_1 (Activation) (None, 2048, 64) 0 batch_normalization_1[0][0] __________________________________________________________________________________________________ conv1d_2 (Conv1D) (None, 2048, 512) 33280 activation_1[0][0] __________________________________________________________________________________________________ batch_normalization_2 (BatchNor (None, 2048, 512) 2048 conv1d_2[0][0] __________________________________________________________________________________________________ activation_2 (Activation) (None, 2048, 512) 0 batch_normalization_2[0][0] __________________________________________________________________________________________________ global_max_pooling1d (GlobalMax (None, 512) 0 activation_2[0][0] __________________________________________________________________________________________________ dense (Dense) (None, 256) 131328 global_max_pooling1d[0][0] __________________________________________________________________________________________________ batch_normalization_3 (BatchNor (None, 256) 1024 dense[0][0] __________________________________________________________________________________________________ activation_3 (Activation) (None, 256) 0 batch_normalization_3[0][0] __________________________________________________________________________________________________ dense_1 (Dense) (None, 128) 32896 activation_3[0][0] __________________________________________________________________________________________________ batch_normalization_4 (BatchNor (None, 128) 512 dense_1[0][0] __________________________________________________________________________________________________ activation_4 (Activation) (None, 128) 0 batch_normalization_4[0][0] __________________________________________________________________________________________________ dense_2 (Dense) (None, 9) 1161 activation_4[0][0] __________________________________________________________________________________________________ reshape (Reshape) (None, 3, 3) 0 dense_2[0][0] __________________________________________________________________________________________________ dot (Dot) (None, 2048, 3) 0 input_1[0][0] reshape[0][0] __________________________________________________________________________________________________ conv1d_3 (Conv1D) (None, 2048, 32) 128 dot[0][0] __________________________________________________________________________________________________ batch_normalization_5 (BatchNor (None, 2048, 32) 128 conv1d_3[0][0] __________________________________________________________________________________________________ activation_5 (Activation) (None, 2048, 32) 0 batch_normalization_5[0][0] __________________________________________________________________________________________________ conv1d_4 (Conv1D) (None, 2048, 32) 1056 activation_5[0][0] __________________________________________________________________________________________________ batch_normalization_6 (BatchNor (None, 2048, 32) 128 conv1d_4[0][0] __________________________________________________________________________________________________ activation_6 (Activation) (None, 2048, 32) 0 batch_normalization_6[0][0] __________________________________________________________________________________________________ conv1d_5 (Conv1D) (None, 2048, 32) 1056 activation_6[0][0] __________________________________________________________________________________________________ batch_normalization_7 (BatchNor (None, 2048, 32) 128 conv1d_5[0][0] __________________________________________________________________________________________________ activation_7 (Activation) (None, 2048, 32) 0 batch_normalization_7[0][0] __________________________________________________________________________________________________ conv1d_6 (Conv1D) (None, 2048, 64) 2112 activation_7[0][0] __________________________________________________________________________________________________ batch_normalization_8 (BatchNor (None, 2048, 64) 256 conv1d_6[0][0] __________________________________________________________________________________________________ activation_8 (Activation) (None, 2048, 64) 0 batch_normalization_8[0][0] __________________________________________________________________________________________________ conv1d_7 (Conv1D) (None, 2048, 512) 33280 activation_8[0][0] __________________________________________________________________________________________________ batch_normalization_9 (BatchNor (None, 2048, 512) 2048 conv1d_7[0][0] __________________________________________________________________________________________________ activation_9 (Activation) (None, 2048, 512) 0 batch_normalization_9[0][0] __________________________________________________________________________________________________ global_max_pooling1d_1 (GlobalM (None, 512) 0 activation_9[0][0] __________________________________________________________________________________________________ dense_3 (Dense) (None, 256) 131328 global_max_pooling1d_1[0][0] __________________________________________________________________________________________________ batch_normalization_10 (BatchNo (None, 256) 1024 dense_3[0][0] __________________________________________________________________________________________________ activation_10 (Activation) (None, 256) 0 batch_normalization_10[0][0] __________________________________________________________________________________________________ dense_4 (Dense) (None, 128) 32896 activation_10[0][0] __________________________________________________________________________________________________ batch_normalization_11 (BatchNo (None, 128) 512 dense_4[0][0] __________________________________________________________________________________________________ activation_11 (Activation) (None, 128) 0 batch_normalization_11[0][0] __________________________________________________________________________________________________ dense_5 (Dense) (None, 1024) 132096 activation_11[0][0] __________________________________________________________________________________________________ reshape_1 (Reshape) (None, 32, 32) 0 dense_5[0][0] __________________________________________________________________________________________________ dot_1 (Dot) (None, 2048, 32) 0 activation_6[0][0] reshape_1[0][0] __________________________________________________________________________________________________ conv1d_8 (Conv1D) (None, 2048, 32) 1056 dot_1[0][0] __________________________________________________________________________________________________ batch_normalization_12 (BatchNo (None, 2048, 32) 128 conv1d_8[0][0] __________________________________________________________________________________________________ activation_12 (Activation) (None, 2048, 32) 0 batch_normalization_12[0][0] __________________________________________________________________________________________________ conv1d_9 (Conv1D) (None, 2048, 64) 2112 activation_12[0][0] __________________________________________________________________________________________________ batch_normalization_13 (BatchNo (None, 2048, 64) 256 conv1d_9[0][0] __________________________________________________________________________________________________ activation_13 (Activation) (None, 2048, 64) 0 batch_normalization_13[0][0] __________________________________________________________________________________________________ conv1d_10 (Conv1D) (None, 2048, 512) 33280 activation_13[0][0] __________________________________________________________________________________________________ batch_normalization_14 (BatchNo (None, 2048, 512) 2048 conv1d_10[0][0] __________________________________________________________________________________________________ activation_14 (Activation) (None, 2048, 512) 0 batch_normalization_14[0][0] __________________________________________________________________________________________________ global_max_pooling1d_2 (GlobalM (None, 512) 0 activation_14[0][0] __________________________________________________________________________________________________ dense_6 (Dense) (None, 256) 131328 global_max_pooling1d_2[0][0] __________________________________________________________________________________________________ batch_normalization_15 (BatchNo (None, 256) 1024 dense_6[0][0] __________________________________________________________________________________________________ activation_15 (Activation) (None, 256) 0 batch_normalization_15[0][0] __________________________________________________________________________________________________ dropout (Dropout) (None, 256) 0 activation_15[0][0] __________________________________________________________________________________________________ dense_7 (Dense) (None, 128) 32896 dropout[0][0] __________________________________________________________________________________________________ batch_normalization_16 (BatchNo (None, 128) 512 dense_7[0][0] __________________________________________________________________________________________________ activation_16 (Activation) (None, 128) 0 batch_normalization_16[0][0] __________________________________________________________________________________________________ dropout_1 (Dropout) (None, 128) 0 activation_16[0][0] __________________________________________________________________________________________________ dense_8 (Dense) (None, 10) 1290 dropout_1[0][0] ================================================================================================== Total params: 748,979 Trainable params: 742,899 Non-trainable params: 6,080 __________________________________________________________________________________________________ Train model Once the model is defined it can be trained like any other standard classification model using .compile() and .fit(). model.compile( loss=\"sparse_categorical_crossentropy\", optimizer=keras.optimizers.Adam(learning_rate=0.001), metrics=[\"sparse_categorical_accuracy\"], ) model.fit(train_dataset, epochs=20, validation_data=test_dataset) Epoch 1/20 125/125 [==============================] - 28s 221ms/step - loss: 3.5897 - sparse_categorical_accuracy: 0.2724 - val_loss: 5804697916006203392.0000 - val_sparse_categorical_accuracy: 0.3073 Epoch 2/20 125/125 [==============================] - 27s 215ms/step - loss: 3.1970 - sparse_categorical_accuracy: 0.3443 - val_loss: 836343949164544.0000 - val_sparse_categorical_accuracy: 0.3425 Epoch 3/20 125/125 [==============================] - 27s 215ms/step - loss: 2.8959 - sparse_categorical_accuracy: 0.4260 - val_loss: 15107376738729984.0000 - val_sparse_categorical_accuracy: 0.3084 Epoch 4/20 125/125 [==============================] - 27s 215ms/step - loss: 2.7148 - sparse_categorical_accuracy: 0.4939 - val_loss: 6823221.0000 - val_sparse_categorical_accuracy: 0.3304 Epoch 5/20 125/125 [==============================] - 27s 215ms/step - loss: 2.5500 - sparse_categorical_accuracy: 0.5560 - val_loss: 675110905872323182592.0000 - val_sparse_categorical_accuracy: 0.4493 Epoch 6/20 125/125 [==============================] - 27s 215ms/step - loss: 2.3595 - sparse_categorical_accuracy: 0.6081 - val_loss: 600389124096.0000 - val_sparse_categorical_accuracy: 0.5749 Epoch 7/20 125/125 [==============================] - 27s 215ms/step - loss: 2.2485 - sparse_categorical_accuracy: 0.6394 - val_loss: 680423464582760103936.0000 - val_sparse_categorical_accuracy: 0.4912 Epoch 8/20 125/125 [==============================] - 27s 215ms/step - loss: 2.1945 - sparse_categorical_accuracy: 0.6575 - val_loss: 44108689408.0000 - val_sparse_categorical_accuracy: 0.6410 Epoch 9/20 125/125 [==============================] - 27s 215ms/step - loss: 2.1318 - sparse_categorical_accuracy: 0.6725 - val_loss: 873314112.0000 - val_sparse_categorical_accuracy: 0.6112 Epoch 10/20 125/125 [==============================] - 27s 215ms/step - loss: 2.0140 - sparse_categorical_accuracy: 0.7018 - val_loss: 13168980992.0000 - val_sparse_categorical_accuracy: 0.6784 Epoch 11/20 125/125 [==============================] - 27s 215ms/step - loss: 1.9929 - sparse_categorical_accuracy: 0.7056 - val_loss: 36888236785664.0000 - val_sparse_categorical_accuracy: 0.6586 Epoch 12/20 125/125 [==============================] - 27s 215ms/step - loss: 1.9542 - sparse_categorical_accuracy: 0.7166 - val_loss: 85375.9844 - val_sparse_categorical_accuracy: 0.7026 Epoch 13/20 125/125 [==============================] - 27s 215ms/step - loss: 1.8648 - sparse_categorical_accuracy: 0.7447 - val_loss: 7.7962 - val_sparse_categorical_accuracy: 0.5441 Epoch 14/20 125/125 [==============================] - 27s 215ms/step - loss: 1.9016 - sparse_categorical_accuracy: 0.7444 - val_loss: 66469.9062 - val_sparse_categorical_accuracy: 0.6134 Epoch 15/20 125/125 [==============================] - 27s 215ms/step - loss: 1.8003 - sparse_categorical_accuracy: 0.7695 - val_loss: 519227186348032.0000 - val_sparse_categorical_accuracy: 0.6949 Epoch 16/20 125/125 [==============================] - 27s 215ms/step - loss: 1.8019 - sparse_categorical_accuracy: 0.7702 - val_loss: 5263462156149188460544.0000 - val_sparse_categorical_accuracy: 0.6520 Epoch 17/20 125/125 [==============================] - 27s 215ms/step - loss: 1.7177 - sparse_categorical_accuracy: 0.7903 - val_loss: 142240048.0000 - val_sparse_categorical_accuracy: 0.7941 Epoch 18/20 125/125 [==============================] - 27s 216ms/step - loss: 1.7548 - sparse_categorical_accuracy: 0.7855 - val_loss: 2.6049 - val_sparse_categorical_accuracy: 0.5022 Epoch 19/20 125/125 [==============================] - 27s 215ms/step - loss: 1.7101 - sparse_categorical_accuracy: 0.8003 - val_loss: 1152819181305987072.0000 - val_sparse_categorical_accuracy: 0.7753 Epoch 20/20 125/125 [==============================] - 27s 215ms/step - loss: 1.6812 - sparse_categorical_accuracy: 0.8176 - val_loss: 12854714433536.0000 - val_sparse_categorical_accuracy: 0.7390 Visualize predictions We can use matplotlib to visualize our trained model performance. data = test_dataset.take(1) points, labels = list(data)[0] points = points[:8, ...] labels = labels[:8, ...] # run test data through model preds = model.predict(points) preds = tf.math.argmax(preds, -1) points = points.numpy() # plot points with predicted class and label fig = plt.figure(figsize=(15, 10)) for i in range(8): ax = fig.add_subplot(2, 4, i + 1, projection=\"3d\") ax.scatter(points[i, :, 0], points[i, :, 1], points[i, :, 2]) ax.set_title( \"pred: {:}, label: {:}\".format( CLASS_MAP[preds[i].numpy()], CLASS_MAP[labels.numpy()[i]] ) ) ax.set_axis_off() plt.show() png Implementation of a PointNet-based model for segmenting point clouds. Introduction A \"point cloud\" is an important type of data structure for storing geometric shape data. Due to its irregular format, it's often transformed into regular 3D voxel grids or collections of images before being used in deep learning applications, a step which makes the data unnecessarily large. The PointNet family of models solves this problem by directly consuming point clouds, respecting the permutation-invariance property of the point data. The PointNet family of models provides a simple, unified architecture for applications ranging from object classification, part segmentation, to scene semantic parsing. In this example, we demonstrate the implementation of the PointNet architecture for shape segmentation. References PointNet: Deep Learning on Point Sets for 3D Classification and Segmentation Point cloud classification with PointNet Spatial Transformer Networks Imports import os import json import random import numpy as np import pandas as pd from tqdm import tqdm from glob import glob import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import matplotlib.pyplot as plt Downloading Dataset The ShapeNet dataset is an ongoing effort to establish a richly-annotated, large-scale dataset of 3D shapes. ShapeNetCore is a subset of the full ShapeNet dataset with clean single 3D models and manually verified category and alignment annotations. It covers 55 common object categories, with about 51,300 unique 3D models. For this example, we use one of the 12 object categories of PASCAL 3D+, included as part of the ShapenetCore dataset. dataset_url = \"https://git.io/JiY4i\" dataset_path = keras.utils.get_file( fname=\"shapenet.zip\", origin=dataset_url, cache_subdir=\"datasets\", hash_algorithm=\"auto\", extract=True, archive_format=\"auto\", cache_dir=\"datasets\", ) Loading the dataset We parse the dataset metadata in order to easily map model categories to their respective directories and segmentation classes to colors for the purpose of visualization. with open(\"/tmp/.keras/datasets/PartAnnotation/metadata.json\") as json_file: metadata = json.load(json_file) print(metadata) {'Airplane': {'directory': '02691156', 'lables': ['wing', 'body', 'tail', 'engine'], 'colors': ['blue', 'green', 'red', 'pink']}, 'Bag': {'directory': '02773838', 'lables': ['handle', 'body'], 'colors': ['blue', 'green']}, 'Cap': {'directory': '02954340', 'lables': ['panels', 'peak'], 'colors': ['blue', 'green']}, 'Car': {'directory': '02958343', 'lables': ['wheel', 'hood', 'roof'], 'colors': ['blue', 'green', 'red']}, 'Chair': {'directory': '03001627', 'lables': ['leg', 'arm', 'back', 'seat'], 'colors': ['blue', 'green', 'red', 'pink']}, 'Earphone': {'directory': '03261776', 'lables': ['earphone', 'headband'], 'colors': ['blue', 'green']}, 'Guitar': {'directory': '03467517', 'lables': ['head', 'body', 'neck'], 'colors': ['blue', 'green', 'red']}, 'Knife': {'directory': '03624134', 'lables': ['handle', 'blade'], 'colors': ['blue', 'green']}, 'Lamp': {'directory': '03636649', 'lables': ['canopy', 'lampshade', 'base'], 'colors': ['blue', 'green', 'red']}, 'Laptop': {'directory': '03642806', 'lables': ['keyboard'], 'colors': ['blue']}, 'Motorbike': {'directory': '03790512', 'lables': ['wheel', 'handle', 'gas_tank', 'light', 'seat'], 'colors': ['blue', 'green', 'red', 'pink', 'yellow']}, 'Mug': {'directory': '03797390', 'lables': ['handle'], 'colors': ['blue']}, 'Pistol': {'directory': '03948459', 'lables': ['trigger_and_guard', 'handle', 'barrel'], 'colors': ['blue', 'green', 'red']}, 'Rocket': {'directory': '04099429', 'lables': ['nose', 'body', 'fin'], 'colors': ['blue', 'green', 'red']}, 'Skateboard': {'directory': '04225987', 'lables': ['wheel', 'deck'], 'colors': ['blue', 'green']}, 'Table': {'directory': '04379243', 'lables': ['leg', 'top'], 'colors': ['blue', 'green']}} In this example, we train PointNet to segment the parts of an Airplane model. points_dir = \"/tmp/.keras/datasets/PartAnnotation/{}/points\".format( metadata[\"Airplane\"][\"directory\"] ) labels_dir = \"/tmp/.keras/datasets/PartAnnotation/{}/points_label\".format( metadata[\"Airplane\"][\"directory\"] ) LABELS = metadata[\"Airplane\"][\"lables\"] COLORS = metadata[\"Airplane\"][\"colors\"] VAL_SPLIT = 0.2 NUM_SAMPLE_POINTS = 1024 BATCH_SIZE = 32 EPOCHS = 60 INITIAL_LR = 1e-3 Structuring the dataset We generate the following in-memory data structures from the Airplane point clouds and their labels: point_clouds is a list of np.array objects that represent the point cloud data in the form of x, y and z coordinates. Axis 0 represents the number of points in the point cloud, while axis 1 represents the coordinates. all_labels is the list that represents the label of each coordinate as a string (needed mainly for visualization purposes). test_point_clouds is in the same format as point_clouds, but doesn't have corresponding the labels of the point clouds. all_labels is a list of np.array objects that represent the point cloud labels for each coordinate, corresponding to the point_clouds list. point_cloud_labels is a list of np.array objects that represent the point cloud labels for each coordinate in one-hot encoded form, corresponding to the point_clouds list. point_clouds, test_point_clouds = [], [] point_cloud_labels, all_labels = [], [] points_files = glob(os.path.join(points_dir, \"*.pts\")) for point_file in tqdm(points_files): point_cloud = np.loadtxt(point_file) if point_cloud.shape[0] < NUM_SAMPLE_POINTS: continue # Get the file-id of the current point cloud for parsing its # labels. file_id = point_file.split(\"/\")[-1].split(\".\")[0] label_data, num_labels = {}, 0 for label in LABELS: label_file = os.path.join(labels_dir, label, file_id + \".seg\") if os.path.exists(label_file): label_data[label] = np.loadtxt(label_file).astype(\"float32\") num_labels = len(label_data[label]) # Point clouds having labels will be our training samples. try: label_map = [\"none\"] * num_labels for label in LABELS: for i, data in enumerate(label_data[label]): label_map[i] = label if data == 1 else label_map[i] label_data = [ LABELS.index(label) if label != \"none\" else len(LABELS) for label in label_map ] # Apply one-hot encoding to the dense label representation. label_data = keras.utils.to_categorical(label_data, num_classes=len(LABELS) + 1) point_clouds.append(point_cloud) point_cloud_labels.append(label_data) all_labels.append(label_map) except KeyError: test_point_clouds.append(point_cloud) 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4045/4045 [03:35<00:00, 18.76it/s] Next, we take a look at some samples from the in-memory arrays we just generated: for _ in range(5): i = random.randint(0, len(point_clouds) - 1) print(f\"point_clouds[{i}].shape:\", point_clouds[0].shape) print(f\"point_cloud_labels[{i}].shape:\", point_cloud_labels[0].shape) for j in range(5): print( f\"all_labels[{i}][{j}]:\", all_labels[i][j], f\"\tpoint_cloud_labels[{i}][{j}]:\", point_cloud_labels[i][j], \"\n\", ) point_clouds[475].shape: (2602, 3) point_cloud_labels[475].shape: (2602, 5) all_labels[475][0]: body point_cloud_labels[475][0]: [0. 1. 0. 0. 0.] all_labels[475][1]: engine point_cloud_labels[475][1]: [0. 0. 0. 1. 0.] all_labels[475][2]: body point_cloud_labels[475][2]: [0. 1. 0. 0. 0.] all_labels[475][3]: body point_cloud_labels[475][3]: [0. 1. 0. 0. 0.] all_labels[475][4]: wing point_cloud_labels[475][4]: [1. 0. 0. 0. 0.] point_clouds[2712].shape: (2602, 3) point_cloud_labels[2712].shape: (2602, 5) all_labels[2712][0]: tail point_cloud_labels[2712][0]: [0. 0. 1. 0. 0.] all_labels[2712][1]: wing point_cloud_labels[2712][1]: [1. 0. 0. 0. 0.] all_labels[2712][2]: engine point_cloud_labels[2712][2]: [0. 0. 0. 1. 0.] all_labels[2712][3]: wing point_cloud_labels[2712][3]: [1. 0. 0. 0. 0.] all_labels[2712][4]: wing point_cloud_labels[2712][4]: [1. 0. 0. 0. 0.] point_clouds[1413].shape: (2602, 3) point_cloud_labels[1413].shape: (2602, 5) all_labels[1413][0]: body point_cloud_labels[1413][0]: [0. 1. 0. 0. 0.] all_labels[1413][1]: tail point_cloud_labels[1413][1]: [0. 0. 1. 0. 0.] all_labels[1413][2]: tail point_cloud_labels[1413][2]: [0. 0. 1. 0. 0.] all_labels[1413][3]: tail point_cloud_labels[1413][3]: [0. 0. 1. 0. 0.] all_labels[1413][4]: tail point_cloud_labels[1413][4]: [0. 0. 1. 0. 0.] point_clouds[1207].shape: (2602, 3) point_cloud_labels[1207].shape: (2602, 5) all_labels[1207][0]: tail point_cloud_labels[1207][0]: [0. 0. 1. 0. 0.] all_labels[1207][1]: wing point_cloud_labels[1207][1]: [1. 0. 0. 0. 0.] all_labels[1207][2]: wing point_cloud_labels[1207][2]: [1. 0. 0. 0. 0.] all_labels[1207][3]: body point_cloud_labels[1207][3]: [0. 1. 0. 0. 0.] all_labels[1207][4]: body point_cloud_labels[1207][4]: [0. 1. 0. 0. 0.] point_clouds[2492].shape: (2602, 3) point_cloud_labels[2492].shape: (2602, 5) all_labels[2492][0]: engine point_cloud_labels[2492][0]: [0. 0. 0. 1. 0.] all_labels[2492][1]: body point_cloud_labels[2492][1]: [0. 1. 0. 0. 0.] all_labels[2492][2]: body point_cloud_labels[2492][2]: [0. 1. 0. 0. 0.] all_labels[2492][3]: body point_cloud_labels[2492][3]: [0. 1. 0. 0. 0.] all_labels[2492][4]: engine point_cloud_labels[2492][4]: [0. 0. 0. 1. 0.] Now, let's visualize some of the point clouds along with their labels. def visualize_data(point_cloud, labels): df = pd.DataFrame( data={ \"x\": point_cloud[:, 0], \"y\": point_cloud[:, 1], \"z\": point_cloud[:, 2], \"label\": labels, } ) fig = plt.figure(figsize=(15, 10)) ax = plt.axes(projection=\"3d\") for index, label in enumerate(LABELS): c_df = df[df[\"label\"] == label] try: ax.scatter( c_df[\"x\"], c_df[\"y\"], c_df[\"z\"], label=label, alpha=0.5, c=COLORS[index] ) except IndexError: pass ax.legend() plt.show() visualize_data(point_clouds[0], all_labels[0]) visualize_data(point_clouds[300], all_labels[300]) png png Preprocessing Note that all the point clouds that we have loaded consist of a variable number of points, which makes it difficult for us to batch them together. In order to overcome this problem, we randomly sample a fixed number of points from each point cloud. We also normalize the point clouds in order to make the data scale-invariant. for index in tqdm(range(len(point_clouds))): current_point_cloud = point_clouds[index] current_label_cloud = point_cloud_labels[index] current_labels = all_labels[index] num_points = len(current_point_cloud) # Randomly sampling respective indices. sampled_indices = random.sample(list(range(num_points)), NUM_SAMPLE_POINTS) # Sampling points corresponding to sampled indices. sampled_point_cloud = np.array([current_point_cloud[i] for i in sampled_indices]) # Sampling corresponding one-hot encoded labels. sampled_label_cloud = np.array([current_label_cloud[i] for i in sampled_indices]) # Sampling corresponding labels for visualization. sampled_labels = np.array([current_labels[i] for i in sampled_indices]) # Normalizing sampled point cloud. norm_point_cloud = sampled_point_cloud - np.mean(sampled_point_cloud, axis=0) norm_point_cloud /= np.max(np.linalg.norm(norm_point_cloud, axis=1)) point_clouds[index] = norm_point_cloud point_cloud_labels[index] = sampled_label_cloud all_labels[index] = sampled_labels 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3694/3694 [00:07<00:00, 478.67it/s] Let's visualize the sampled and normalized point clouds along with their corresponding labels. visualize_data(point_clouds[0], all_labels[0]) visualize_data(point_clouds[300], all_labels[300]) png png Creating TensorFlow datasets We create tf.data.Dataset objects for the training and validation data. We also augment the training point clouds by applying random jitter to them. def load_data(point_cloud_batch, label_cloud_batch): point_cloud_batch.set_shape([NUM_SAMPLE_POINTS, 3]) label_cloud_batch.set_shape([NUM_SAMPLE_POINTS, len(LABELS) + 1]) return point_cloud_batch, label_cloud_batch def augment(point_cloud_batch, label_cloud_batch): noise = tf.random.uniform( tf.shape(label_cloud_batch), -0.005, 0.005, dtype=tf.float64 ) point_cloud_batch += noise[:, :, :3] return point_cloud_batch, label_cloud_batch def generate_dataset(point_clouds, label_clouds, is_training=True): dataset = tf.data.Dataset.from_tensor_slices((point_clouds, label_clouds)) dataset = dataset.shuffle(BATCH_SIZE * 100) if is_training else dataset dataset = dataset.map(load_data, num_parallel_calls=tf.data.AUTOTUNE) dataset = dataset.batch(batch_size=BATCH_SIZE) dataset = ( dataset.map(augment, num_parallel_calls=tf.data.AUTOTUNE) if is_training else dataset ) return dataset split_index = int(len(point_clouds) * (1 - VAL_SPLIT)) train_point_clouds = point_clouds[:split_index] train_label_cloud = point_cloud_labels[:split_index] total_training_examples = len(train_point_clouds) val_point_clouds = point_clouds[split_index:] val_label_cloud = point_cloud_labels[split_index:] print(\"Num train point clouds:\", len(train_point_clouds)) print(\"Num train point cloud labels:\", len(train_label_cloud)) print(\"Num val point clouds:\", len(val_point_clouds)) print(\"Num val point cloud labels:\", len(val_label_cloud)) train_dataset = generate_dataset(train_point_clouds, train_label_cloud) val_dataset = generate_dataset(val_point_clouds, val_label_cloud, is_training=False) print(\"Train Dataset:\", train_dataset) print(\"Validation Dataset:\", val_dataset) Num train point clouds: 2955 Num train point cloud labels: 2955 Num val point clouds: 739 Num val point cloud labels: 739 Train Dataset: Validation Dataset: PointNet model The figure below depicts the internals of the PointNet model family: Given that PointNet is meant to consume an unordered set of coordinates as its input data, its architecture needs to match the following characteristic properties of point cloud data: Permutation invariance Given the unstructured nature of point cloud data, a scan made up of n points has n! permutations. The subsequent data processing must be invariant to the different representations. In order to make PointNet invariant to input permutations, we use a symmetric function (such as max-pooling) once the n input points are mapped to higher-dimensional space. The result is a global feature vector that aims to capture an aggregate signature of the n input points. The global feature vector is used alongside local point features for segmentation. Transformation invariance Segmentation outputs should be unchanged if the object undergoes certain transformations, such as translation or scaling. For a given input point cloud, we apply an appropriate rigid or affine transformation to achieve pose normalization. Because each of the n input points are represented as a vector and are mapped to the embedding spaces independently, applying a geometric transformation simply amounts to matrix multiplying each point with a transformation matrix. This is motivated by the concept of Spatial Transformer Networks. The operations comprising the T-Net are motivated by the higher-level architecture of PointNet. MLPs (or fully-connected layers) are used to map the input points independently and identically to a higher-dimensional space; max-pooling is used to encode a global feature vector whose dimensionality is then reduced with fully-connected layers. The input-dependent features at the final fully-connected layer are then combined with globally trainable weights and biases, resulting in a 3-by-3 transformation matrix. Point interactions The interaction between neighboring points often carries useful information (i.e., a single point should not be treated in isolation). Whereas classification need only make use of global features, segmentation must be able to leverage local point features along with global point features. Note: The figures presented in this section have been taken from the original paper. Now that we know the pieces that compose the PointNet model, we can implement the model. We start by implementing the basic blocks i.e., the convolutional block and the multi-layer perceptron block. def conv_block(x: tf.Tensor, filters: int, name: str) -> tf.Tensor: x = layers.Conv1D(filters, kernel_size=1, padding=\"valid\", name=f\"{name}_conv\")(x) x = layers.BatchNormalization(momentum=0.0, name=f\"{name}_batch_norm\")(x) return layers.Activation(\"relu\", name=f\"{name}_relu\")(x) def mlp_block(x: tf.Tensor, filters: int, name: str) -> tf.Tensor: x = layers.Dense(filters, name=f\"{name}_dense\")(x) x = layers.BatchNormalization(momentum=0.0, name=f\"{name}_batch_norm\")(x) return layers.Activation(\"relu\", name=f\"{name}_relu\")(x) We implement a regularizer (taken from this example) to enforce orthogonality in the feature space. This is needed to ensure that the magnitudes of the transformed features do not vary too much. class OrthogonalRegularizer(keras.regularizers.Regularizer): \"\"\"Reference: https://keras.io/examples/vision/pointnet/#build-a-model\"\"\" def __init__(self, num_features, l2reg=0.001): self.num_features = num_features self.l2reg = l2reg self.identity = tf.eye(num_features) def __call__(self, x): x = tf.reshape(x, (-1, self.num_features, self.num_features)) xxt = tf.tensordot(x, x, axes=(2, 2)) xxt = tf.reshape(xxt, (-1, self.num_features, self.num_features)) return tf.reduce_sum(self.l2reg * tf.square(xxt - self.identity)) def get_config(self): config = super(TransformerEncoder, self).get_config() config.update({\"num_features\": self.num_features, \"l2reg_strength\": self.l2reg}) return config The next piece is the transformation network which we explained earlier. def transformation_net(inputs: tf.Tensor, num_features: int, name: str) -> tf.Tensor: \"\"\" Reference: https://keras.io/examples/vision/pointnet/#build-a-model. The `filters` values come from the original paper: https://arxiv.org/abs/1612.00593. \"\"\" x = conv_block(inputs, filters=64, name=f\"{name}_1\") x = conv_block(x, filters=128, name=f\"{name}_2\") x = conv_block(x, filters=1024, name=f\"{name}_3\") x = layers.GlobalMaxPooling1D()(x) x = mlp_block(x, filters=512, name=f\"{name}_1_1\") x = mlp_block(x, filters=256, name=f\"{name}_2_1\") return layers.Dense( num_features * num_features, kernel_initializer=\"zeros\", bias_initializer=keras.initializers.Constant(np.eye(num_features).flatten()), activity_regularizer=OrthogonalRegularizer(num_features), name=f\"{name}_final\", )(x) def transformation_block(inputs: tf.Tensor, num_features: int, name: str) -> tf.Tensor: transformed_features = transformation_net(inputs, num_features, name=name) transformed_features = layers.Reshape((num_features, num_features))( transformed_features ) return layers.Dot(axes=(2, 1), name=f\"{name}_mm\")([inputs, transformed_features]) Finally, we piece the above blocks together and implement the segmentation model. def get_shape_segmentation_model(num_points: int, num_classes: int) -> keras.Model: input_points = keras.Input(shape=(None, 3)) # PointNet Classification Network. transformed_inputs = transformation_block( input_points, num_features=3, name=\"input_transformation_block\" ) features_64 = conv_block(transformed_inputs, filters=64, name=\"features_64\") features_128_1 = conv_block(features_64, filters=128, name=\"features_128_1\") features_128_2 = conv_block(features_128_1, filters=128, name=\"features_128_2\") transformed_features = transformation_block( features_128_2, num_features=128, name=\"transformed_features\" ) features_512 = conv_block(transformed_features, filters=512, name=\"features_512\") features_2048 = conv_block(features_512, filters=2048, name=\"pre_maxpool_block\") global_features = layers.MaxPool1D(pool_size=num_points, name=\"global_features\")( features_2048 ) global_features = tf.tile(global_features, [1, num_points, 1]) # Segmentation head. segmentation_input = layers.Concatenate(name=\"segmentation_input\")( [ features_64, features_128_1, features_128_2, transformed_features, features_512, global_features, ] ) segmentation_features = conv_block( segmentation_input, filters=128, name=\"segmentation_features\" ) outputs = layers.Conv1D( num_classes, kernel_size=1, activation=\"softmax\", name=\"segmentation_head\" )(segmentation_features) return keras.Model(input_points, outputs) Instantiate the model x, y = next(iter(train_dataset)) num_points = x.shape[1] num_classes = y.shape[-1] segmentation_model = get_shape_segmentation_model(num_points, num_classes) segmentation_model.summary() 2021-10-25 01:26:33.563133: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2) Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, None, 3)] 0 __________________________________________________________________________________________________ input_transformation_block_1_co (None, None, 64) 256 input_1[0][0] __________________________________________________________________________________________________ input_transformation_block_1_ba (None, None, 64) 256 input_transformation_block_1_conv __________________________________________________________________________________________________ input_transformation_block_1_re (None, None, 64) 0 input_transformation_block_1_batc __________________________________________________________________________________________________ input_transformation_block_2_co (None, None, 128) 8320 input_transformation_block_1_relu __________________________________________________________________________________________________ input_transformation_block_2_ba (None, None, 128) 512 input_transformation_block_2_conv __________________________________________________________________________________________________ input_transformation_block_2_re (None, None, 128) 0 input_transformation_block_2_batc __________________________________________________________________________________________________ input_transformation_block_3_co (None, None, 1024) 132096 input_transformation_block_2_relu __________________________________________________________________________________________________ input_transformation_block_3_ba (None, None, 1024) 4096 input_transformation_block_3_conv __________________________________________________________________________________________________ input_transformation_block_3_re (None, None, 1024) 0 input_transformation_block_3_batc __________________________________________________________________________________________________ global_max_pooling1d (GlobalMax (None, 1024) 0 input_transformation_block_3_relu __________________________________________________________________________________________________ input_transformation_block_1_1_ (None, 512) 524800 global_max_pooling1d[0][0] __________________________________________________________________________________________________ input_transformation_block_1_1_ (None, 512) 2048 input_transformation_block_1_1_de __________________________________________________________________________________________________ input_transformation_block_1_1_ (None, 512) 0 input_transformation_block_1_1_ba __________________________________________________________________________________________________ input_transformation_block_2_1_ (None, 256) 131328 input_transformation_block_1_1_re __________________________________________________________________________________________________ input_transformation_block_2_1_ (None, 256) 1024 input_transformation_block_2_1_de __________________________________________________________________________________________________ input_transformation_block_2_1_ (None, 256) 0 input_transformation_block_2_1_ba __________________________________________________________________________________________________ input_transformation_block_fina (None, 9) 2313 input_transformation_block_2_1_re __________________________________________________________________________________________________ reshape (Reshape) (None, 3, 3) 0 input_transformation_block_final[ __________________________________________________________________________________________________ input_transformation_block_mm ( (None, None, 3) 0 input_1[0][0] reshape[0][0] __________________________________________________________________________________________________ features_64_conv (Conv1D) (None, None, 64) 256 input_transformation_block_mm[0][ __________________________________________________________________________________________________ features_64_batch_norm (BatchNo (None, None, 64) 256 features_64_conv[0][0] __________________________________________________________________________________________________ features_64_relu (Activation) (None, None, 64) 0 features_64_batch_norm[0][0] __________________________________________________________________________________________________ features_128_1_conv (Conv1D) (None, None, 128) 8320 features_64_relu[0][0] __________________________________________________________________________________________________ features_128_1_batch_norm (Batc (None, None, 128) 512 features_128_1_conv[0][0] __________________________________________________________________________________________________ features_128_1_relu (Activation (None, None, 128) 0 features_128_1_batch_norm[0][0] __________________________________________________________________________________________________ features_128_2_conv (Conv1D) (None, None, 128) 16512 features_128_1_relu[0][0] __________________________________________________________________________________________________ features_128_2_batch_norm (Batc (None, None, 128) 512 features_128_2_conv[0][0] __________________________________________________________________________________________________ features_128_2_relu (Activation (None, None, 128) 0 features_128_2_batch_norm[0][0] __________________________________________________________________________________________________ transformed_features_1_conv (Co (None, None, 64) 8256 features_128_2_relu[0][0] __________________________________________________________________________________________________ transformed_features_1_batch_no (None, None, 64) 256 transformed_features_1_conv[0][0] __________________________________________________________________________________________________ transformed_features_1_relu (Ac (None, None, 64) 0 transformed_features_1_batch_norm __________________________________________________________________________________________________ transformed_features_2_conv (Co (None, None, 128) 8320 transformed_features_1_relu[0][0] __________________________________________________________________________________________________ transformed_features_2_batch_no (None, None, 128) 512 transformed_features_2_conv[0][0] __________________________________________________________________________________________________ transformed_features_2_relu (Ac (None, None, 128) 0 transformed_features_2_batch_norm __________________________________________________________________________________________________ transformed_features_3_conv (Co (None, None, 1024) 132096 transformed_features_2_relu[0][0] __________________________________________________________________________________________________ transformed_features_3_batch_no (None, None, 1024) 4096 transformed_features_3_conv[0][0] __________________________________________________________________________________________________ transformed_features_3_relu (Ac (None, None, 1024) 0 transformed_features_3_batch_norm __________________________________________________________________________________________________ global_max_pooling1d_1 (GlobalM (None, 1024) 0 transformed_features_3_relu[0][0] __________________________________________________________________________________________________ transformed_features_1_1_dense (None, 512) 524800 global_max_pooling1d_1[0][0] __________________________________________________________________________________________________ transformed_features_1_1_batch_ (None, 512) 2048 transformed_features_1_1_dense[0] __________________________________________________________________________________________________ transformed_features_1_1_relu ( (None, 512) 0 transformed_features_1_1_batch_no __________________________________________________________________________________________________ transformed_features_2_1_dense (None, 256) 131328 transformed_features_1_1_relu[0][ __________________________________________________________________________________________________ transformed_features_2_1_batch_ (None, 256) 1024 transformed_features_2_1_dense[0] __________________________________________________________________________________________________ transformed_features_2_1_relu ( (None, 256) 0 transformed_features_2_1_batch_no __________________________________________________________________________________________________ transformed_features_final (Den (None, 16384) 4210688 transformed_features_2_1_relu[0][ __________________________________________________________________________________________________ reshape_1 (Reshape) (None, 128, 128) 0 transformed_features_final[0][0] __________________________________________________________________________________________________ transformed_features_mm (Dot) (None, None, 128) 0 features_128_2_relu[0][0] reshape_1[0][0] __________________________________________________________________________________________________ features_512_conv (Conv1D) (None, None, 512) 66048 transformed_features_mm[0][0] __________________________________________________________________________________________________ features_512_batch_norm (BatchN (None, None, 512) 2048 features_512_conv[0][0] __________________________________________________________________________________________________ features_512_relu (Activation) (None, None, 512) 0 features_512_batch_norm[0][0] __________________________________________________________________________________________________ pre_maxpool_block_conv (Conv1D) (None, None, 2048) 1050624 features_512_relu[0][0] __________________________________________________________________________________________________ pre_maxpool_block_batch_norm (B (None, None, 2048) 8192 pre_maxpool_block_conv[0][0] __________________________________________________________________________________________________ pre_maxpool_block_relu (Activat (None, None, 2048) 0 pre_maxpool_block_batch_norm[0][0 __________________________________________________________________________________________________ global_features (MaxPooling1D) (None, None, 2048) 0 pre_maxpool_block_relu[0][0] __________________________________________________________________________________________________ tf.tile (TFOpLambda) (None, None, 2048) 0 global_features[0][0] __________________________________________________________________________________________________ segmentation_input (Concatenate (None, None, 3008) 0 features_64_relu[0][0] features_128_1_relu[0][0] features_128_2_relu[0][0] transformed_features_mm[0][0] features_512_relu[0][0] tf.tile[0][0] __________________________________________________________________________________________________ segmentation_features_conv (Con (None, None, 128) 385152 segmentation_input[0][0] __________________________________________________________________________________________________ segmentation_features_batch_nor (None, None, 128) 512 segmentation_features_conv[0][0] __________________________________________________________________________________________________ segmentation_features_relu (Act (None, None, 128) 0 segmentation_features_batch_norm[ __________________________________________________________________________________________________ segmentation_head (Conv1D) (None, None, 5) 645 segmentation_features_relu[0][0] ================================================================================================== Total params: 7,370,062 Trainable params: 7,356,110 Non-trainable params: 13,952 __________________________________________________________________________________________________ Training For the training the authors recommend using a learning rate schedule that decays the initial learning rate by half every 20 epochs. In this example, we resort to 15 epochs. training_step_size = total_training_examples // BATCH_SIZE total_training_steps = training_step_size * EPOCHS print(f\"Total training steps: {total_training_steps}.\") lr_schedule = keras.optimizers.schedules.PiecewiseConstantDecay( boundaries=[training_step_size * 15, training_step_size * 15], values=[INITIAL_LR, INITIAL_LR * 0.5, INITIAL_LR * 0.25], ) steps = tf.range(total_training_steps, dtype=tf.int32) lrs = [lr_schedule(step) for step in steps] plt.plot(lrs) plt.xlabel(\"Steps\") plt.ylabel(\"Learning Rate\") plt.show() Total training steps: 5520. png Finally, we implement a utility for running our experiments and launch model training. def run_experiment(epochs): segmentation_model = get_shape_segmentation_model(num_points, num_classes) segmentation_model.compile( optimizer=keras.optimizers.Adam(learning_rate=lr_schedule), loss=keras.losses.CategoricalCrossentropy(), metrics=[\"accuracy\"], ) checkpoint_filepath = \"/tmp/checkpoint\" checkpoint_callback = keras.callbacks.ModelCheckpoint( checkpoint_filepath, monitor=\"val_loss\", save_best_only=True, save_weights_only=True, ) history = segmentation_model.fit( train_dataset, validation_data=val_dataset, epochs=epochs, callbacks=[checkpoint_callback], ) segmentation_model.load_weights(checkpoint_filepath) return segmentation_model, history segmentation_model, history = run_experiment(epochs=EPOCHS) Epoch 1/60 93/93 [==============================] - 28s 127ms/step - loss: 5.3556 - accuracy: 0.7448 - val_loss: 5.8386 - val_accuracy: 0.7471 Epoch 2/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7077 - accuracy: 0.8181 - val_loss: 5.2614 - val_accuracy: 0.7793 Epoch 3/60 93/93 [==============================] - 11s 118ms/step - loss: 4.6566 - accuracy: 0.8301 - val_loss: 4.7907 - val_accuracy: 0.8269 Epoch 4/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6059 - accuracy: 0.8406 - val_loss: 4.6031 - val_accuracy: 0.8482 Epoch 5/60 93/93 [==============================] - 11s 118ms/step - loss: 4.5828 - accuracy: 0.8444 - val_loss: 4.7692 - val_accuracy: 0.8220 Epoch 6/60 93/93 [==============================] - 11s 118ms/step - loss: 4.6150 - accuracy: 0.8408 - val_loss: 5.4460 - val_accuracy: 0.8192 Epoch 7/60 93/93 [==============================] - 11s 117ms/step - loss: 67.5943 - accuracy: 0.7378 - val_loss: 1617.1846 - val_accuracy: 0.5191 Epoch 8/60 93/93 [==============================] - 11s 117ms/step - loss: 15.2910 - accuracy: 0.6651 - val_loss: 8.1014 - val_accuracy: 0.7046 Epoch 9/60 93/93 [==============================] - 11s 117ms/step - loss: 6.8878 - accuracy: 0.7368 - val_loss: 14.2311 - val_accuracy: 0.6949 Epoch 10/60 93/93 [==============================] - 11s 117ms/step - loss: 5.8362 - accuracy: 0.7549 - val_loss: 14.6942 - val_accuracy: 0.6350 Epoch 11/60 93/93 [==============================] - 11s 117ms/step - loss: 5.4777 - accuracy: 0.7648 - val_loss: 44.1037 - val_accuracy: 0.6422 Epoch 12/60 93/93 [==============================] - 11s 117ms/step - loss: 5.2688 - accuracy: 0.7712 - val_loss: 4.9977 - val_accuracy: 0.7692 Epoch 13/60 93/93 [==============================] - 11s 117ms/step - loss: 5.1041 - accuracy: 0.7837 - val_loss: 6.0642 - val_accuracy: 0.7577 Epoch 14/60 93/93 [==============================] - 11s 117ms/step - loss: 5.0011 - accuracy: 0.7862 - val_loss: 4.9313 - val_accuracy: 0.7840 Epoch 15/60 93/93 [==============================] - 11s 117ms/step - loss: 4.8910 - accuracy: 0.7953 - val_loss: 5.8368 - val_accuracy: 0.7725 Epoch 16/60 93/93 [==============================] - 11s 117ms/step - loss: 4.8698 - accuracy: 0.8074 - val_loss: 73.0260 - val_accuracy: 0.7251 Epoch 17/60 93/93 [==============================] - 11s 117ms/step - loss: 4.8299 - accuracy: 0.8109 - val_loss: 17.1503 - val_accuracy: 0.7415 Epoch 18/60 93/93 [==============================] - 11s 117ms/step - loss: 4.8147 - accuracy: 0.8111 - val_loss: 62.2765 - val_accuracy: 0.7344 Epoch 19/60 93/93 [==============================] - 11s 117ms/step - loss: 4.8316 - accuracy: 0.8141 - val_loss: 5.2200 - val_accuracy: 0.7890 Epoch 20/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7853 - accuracy: 0.8142 - val_loss: 5.7062 - val_accuracy: 0.7719 Epoch 21/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7753 - accuracy: 0.8157 - val_loss: 6.2089 - val_accuracy: 0.7839 Epoch 22/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7681 - accuracy: 0.8161 - val_loss: 5.1077 - val_accuracy: 0.8021 Epoch 23/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7554 - accuracy: 0.8187 - val_loss: 4.7912 - val_accuracy: 0.7912 Epoch 24/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7355 - accuracy: 0.8197 - val_loss: 4.9164 - val_accuracy: 0.7978 Epoch 25/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7483 - accuracy: 0.8197 - val_loss: 13.4724 - val_accuracy: 0.7631 Epoch 26/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7200 - accuracy: 0.8218 - val_loss: 8.3074 - val_accuracy: 0.7596 Epoch 27/60 93/93 [==============================] - 11s 118ms/step - loss: 4.7192 - accuracy: 0.8231 - val_loss: 12.4468 - val_accuracy: 0.7591 Epoch 28/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7151 - accuracy: 0.8241 - val_loss: 23.8681 - val_accuracy: 0.7689 Epoch 29/60 93/93 [==============================] - 11s 117ms/step - loss: 4.7096 - accuracy: 0.8237 - val_loss: 4.9069 - val_accuracy: 0.8104 Epoch 30/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6991 - accuracy: 0.8257 - val_loss: 4.9858 - val_accuracy: 0.7950 Epoch 31/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6852 - accuracy: 0.8260 - val_loss: 5.0130 - val_accuracy: 0.7678 Epoch 32/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6630 - accuracy: 0.8286 - val_loss: 4.8523 - val_accuracy: 0.7676 Epoch 33/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6837 - accuracy: 0.8281 - val_loss: 5.4347 - val_accuracy: 0.8095 Epoch 34/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6571 - accuracy: 0.8296 - val_loss: 10.4595 - val_accuracy: 0.7410 Epoch 35/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6460 - accuracy: 0.8321 - val_loss: 4.9189 - val_accuracy: 0.8083 Epoch 36/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6430 - accuracy: 0.8327 - val_loss: 5.8674 - val_accuracy: 0.7911 Epoch 37/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6530 - accuracy: 0.8309 - val_loss: 4.7946 - val_accuracy: 0.8032 Epoch 38/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6391 - accuracy: 0.8318 - val_loss: 5.0111 - val_accuracy: 0.8024 Epoch 39/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6521 - accuracy: 0.8336 - val_loss: 8.1558 - val_accuracy: 0.7727 Epoch 40/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6443 - accuracy: 0.8329 - val_loss: 42.8513 - val_accuracy: 0.7688 Epoch 41/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6316 - accuracy: 0.8342 - val_loss: 5.0960 - val_accuracy: 0.8066 Epoch 42/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6322 - accuracy: 0.8335 - val_loss: 5.0634 - val_accuracy: 0.8158 Epoch 43/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6175 - accuracy: 0.8370 - val_loss: 6.0642 - val_accuracy: 0.8062 Epoch 44/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6175 - accuracy: 0.8371 - val_loss: 11.1805 - val_accuracy: 0.7790 Epoch 45/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6056 - accuracy: 0.8377 - val_loss: 4.7359 - val_accuracy: 0.8145 Epoch 46/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6108 - accuracy: 0.8383 - val_loss: 5.7125 - val_accuracy: 0.7713 Epoch 47/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6103 - accuracy: 0.8377 - val_loss: 6.3271 - val_accuracy: 0.8105 Epoch 48/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6020 - accuracy: 0.8383 - val_loss: 14.2876 - val_accuracy: 0.7529 Epoch 49/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6035 - accuracy: 0.8382 - val_loss: 4.8244 - val_accuracy: 0.8143 Epoch 50/60 93/93 [==============================] - 11s 117ms/step - loss: 4.6076 - accuracy: 0.8381 - val_loss: 8.2636 - val_accuracy: 0.7528 Epoch 51/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5927 - accuracy: 0.8399 - val_loss: 4.6473 - val_accuracy: 0.8266 Epoch 52/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5927 - accuracy: 0.8408 - val_loss: 4.6443 - val_accuracy: 0.8276 Epoch 53/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5852 - accuracy: 0.8413 - val_loss: 5.1300 - val_accuracy: 0.7768 Epoch 54/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5787 - accuracy: 0.8426 - val_loss: 8.9590 - val_accuracy: 0.7582 Epoch 55/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5837 - accuracy: 0.8410 - val_loss: 5.1501 - val_accuracy: 0.8117 Epoch 56/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5875 - accuracy: 0.8422 - val_loss: 31.3518 - val_accuracy: 0.7590 Epoch 57/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5821 - accuracy: 0.8427 - val_loss: 4.8853 - val_accuracy: 0.8144 Epoch 58/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5751 - accuracy: 0.8446 - val_loss: 4.6653 - val_accuracy: 0.8222 Epoch 59/60 93/93 [==============================] - 11s 117ms/step - loss: 4.5752 - accuracy: 0.8447 - val_loss: 6.0078 - val_accuracy: 0.8014 Epoch 60/60 93/93 [==============================] - 11s 118ms/step - loss: 4.5695 - accuracy: 0.8452 - val_loss: 4.8178 - val_accuracy: 0.8192 Visualize the training landscape def plot_result(item): plt.plot(history.history[item], label=item) plt.plot(history.history[\"val_\" + item], label=\"val_\" + item) plt.xlabel(\"Epochs\") plt.ylabel(item) plt.title(\"Train and Validation {} Over Epochs\".format(item), fontsize=14) plt.legend() plt.grid() plt.show() plot_result(\"loss\") plot_result(\"accuracy\") png png Inference validation_batch = next(iter(val_dataset)) val_predictions = segmentation_model.predict(validation_batch[0]) print(f\"Validation prediction shape: {val_predictions.shape}\") def visualize_single_point_cloud(point_clouds, label_clouds, idx): label_map = LABELS + [\"none\"] point_cloud = point_clouds[idx] label_cloud = label_clouds[idx] visualize_data(point_cloud, [label_map[np.argmax(label)] for label in label_cloud]) idx = np.random.choice(len(validation_batch[0])) print(f\"Index selected: {idx}\") # Plotting with ground-truth. visualize_single_point_cloud(validation_batch[0], validation_batch[1], idx) # Plotting with predicted labels. visualize_single_point_cloud(validation_batch[0], val_predictions, idx) Validation prediction shape: (32, 1024, 5) Index selected: 24 png png Final notes If you are interested in learning more about this topic, you may find this repository useful. RandAugment for training an image classification model with improved robustness. Data augmentation is a very useful technique that can help to improve the translational invariance of convolutional neural networks (CNN). RandAugment is a stochastic data augmentation routine for vision data and was proposed in RandAugment: Practical automated data augmentation with a reduced search space. It is composed of strong augmentation transforms like color jitters, Gaussian blurs, saturations, etc. along with more traditional augmentation transforms such as random crops. RandAugment has two parameters: n that denotes the number of randomly selected augmentation transforms to apply sequentially m strength of all the augmentation transforms These parameters are tuned for a given dataset and a network architecture. The authors of RandAugment also provide pseudocode of RandAugment in the original paper (Figure 2). Recently, it has been a key component of works like Noisy Student Training and Unsupervised Data Augmentation for Consistency Training. It has been also central to the success of EfficientNets. This example requires TensorFlow 2.4 or higher, as well as imgaug, which can be installed using the following command: pip install imgaug Imports & setup import tensorflow as tf import numpy as np import matplotlib.pyplot as plt from tensorflow.keras import layers import tensorflow_datasets as tfds from imgaug import augmenters as iaa import imgaug as ia tfds.disable_progress_bar() tf.random.set_seed(42) ia.seed(42) Load the CIFAR10 dataset For this example, we will be using the CIFAR10 dataset. (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data() print(f\"Total training examples: {len(x_train)}\") print(f\"Total test examples: {len(x_test)}\") Total training examples: 50000 Total test examples: 10000 Define hyperparameters AUTO = tf.data.AUTOTUNE BATCH_SIZE = 128 EPOCHS = 1 IMAGE_SIZE = 72 Initialize RandAugment object Now, we will initialize a RandAugment object from the imgaug.augmenters module with the parameters suggested by the RandAugment authors. rand_aug = iaa.RandAugment(n=3, m=7) def augment(images): # Input to `augment()` is a TensorFlow tensor which # is not supported by `imgaug`. This is why we first # convert it to its `numpy` variant. images = tf.cast(images, tf.uint8) return rand_aug(images=images.numpy()) Create TensorFlow Dataset objects Because RandAugment can only process NumPy arrays, it cannot be applied directly as part of the Dataset object (which expects TensorFlow tensors). To make RandAugment part of the dataset, we need to wrap it in a [tf.py_function](https://www.tensorflow.org/api_docs/python/tf/py_function). A tf.py_function is a TensorFlow operation (which, like any other TensorFlow operation, takes TF tensors as arguments and returns TensorFlow tensors) that is capable of running arbitrary Python code. Naturally, this Python code can only be executed on CPU (whereas the rest of the TensorFlow graph can be accelerated on GPU), which in some cases can cause significant slowdowns -- however, in this case, the Dataset pipeline will run asynchronously together with the model, and doing preprocessing on CPU will remain performant. train_ds_rand = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(BATCH_SIZE * 100) .batch(BATCH_SIZE) .map( lambda x, y: (tf.image.resize(x, (IMAGE_SIZE, IMAGE_SIZE)), y), num_parallel_calls=AUTO, ) .map( lambda x, y: (tf.py_function(augment, [x], [tf.float32])[0], y), num_parallel_calls=AUTO, ) .prefetch(AUTO) ) test_ds = ( tf.data.Dataset.from_tensor_slices((x_test, y_test)) .batch(BATCH_SIZE) .map( lambda x, y: (tf.image.resize(x, (IMAGE_SIZE, IMAGE_SIZE)), y), num_parallel_calls=AUTO, ) .prefetch(AUTO) ) Note about using tf.py_function: As our augment() function is not a native TensorFlow operation chances are likely that it can turn into an expensive operation. This is why it is much better to apply it after batching our dataset. tf.py_function is not compatible with TPUs. So, if you have distributed TensorFlow training pipelines that use TPUs you cannot use tf.py_function. In that case, consider switching to a multi-GPU environment, or rewriting the contents of the function in pure TensorFlow. For comparison purposes, let's also define a simple augmentation pipeline consisting of random flips, random rotations, and random zoomings. simple_aug = tf.keras.Sequential( [ layers.Resizing(IMAGE_SIZE, IMAGE_SIZE), layers.RandomFlip(\"horizontal\"), layers.RandomRotation(factor=0.02), layers.RandomZoom( height_factor=0.2, width_factor=0.2 ), ] ) # Now, map the augmentation pipeline to our training dataset train_ds_simple = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(BATCH_SIZE * 100) .batch(BATCH_SIZE) .map(lambda x, y: (simple_aug(x), y), num_parallel_calls=AUTO) .prefetch(AUTO) ) Visualize the dataset augmented with RandAugment sample_images, _ = next(iter(train_ds_rand)) plt.figure(figsize=(10, 10)) for i, image in enumerate(sample_images[:9]): ax = plt.subplot(3, 3, i + 1) plt.imshow(image.numpy().astype(\"int\")) plt.axis(\"off\") png You are encouraged to run the above code block a couple of times to see different variations. Visualize the dataset augmented with simple_aug sample_images, _ = next(iter(train_ds_simple)) plt.figure(figsize=(10, 10)) for i, image in enumerate(sample_images[:9]): ax = plt.subplot(3, 3, i + 1) plt.imshow(image.numpy().astype(\"int\")) plt.axis(\"off\") png Define a model building utility function Now, we define a CNN model that is based on the ResNet50V2 architecture. Also, notice that the network already has a rescaling layer inside it. This eliminates the need to do any separate preprocessing on our dataset and is specifically very useful for deployment purposes. def get_training_model(): resnet50_v2 = tf.keras.applications.ResNet50V2( weights=None, include_top=True, input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), classes=10, ) model = tf.keras.Sequential( [ layers.Input((IMAGE_SIZE, IMAGE_SIZE, 3)), layers.Rescaling(scale=1.0 / 127.5, offset=-1), resnet50_v2, ] ) return model print(get_training_model().summary() Model: \"sequential_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= rescaling (Rescaling) (None, 72, 72, 3) 0 _________________________________________________________________ resnet50v2 (Functional) (None, 10) 23585290 ================================================================= Total params: 23,585,290 Trainable params: 23,539,850 Non-trainable params: 45,440 _________________________________________________________________ We will train this network on two different versions of our dataset: One augmented with RandAugment. Another one augmented with simple_aug. Since RandAugment is known to enhance the robustness of models to common perturbations and corruptions, we will also evaluate our models on the CIFAR-10-C dataset, proposed in Benchmarking Neural Network Robustness to Common Corruptions and Perturbations by Hendrycks et al. The CIFAR-10-C dataset consists of 19 different image corruptions and perturbations (for example speckle noise, fog, Gaussian blur, etc.) that too at varying severity levels. For this example we will be using the following configuration: cifar10_corrupted/saturate_5. The images from this configuration look like so: In the interest of reproducibility, we serialize the initial random weights of our shallow network. initial_model = get_training_model() initial_model.save_weights(\"initial_weights.h5\") Train model with RandAugment rand_aug_model = get_training_model() rand_aug_model.load_weights(\"initial_weights.h5\") rand_aug_model.compile( loss=\"sparse_categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"] ) rand_aug_model.fit(train_ds_rand, validation_data=test_ds, epochs=EPOCHS) _, test_acc = rand_aug_model.evaluate(test_ds) print(\"Test accuracy: {:.2f}%\".format(test_acc * 100)) 391/391 [==============================] - 1199s 3s/step - loss: 2.0652 - accuracy: 0.2744 - val_loss: 1.6281 - val_accuracy: 0.4319 79/79 [==============================] - 46s 580ms/step - loss: 1.6281 - accuracy: 0.4319 Test accuracy: 43.19% Train model with simple_aug simple_aug_model = get_training_model() simple_aug_model.load_weights(\"initial_weights.h5\") simple_aug_model.compile( loss=\"sparse_categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"] ) simple_aug_model.fit(train_ds_simple, validation_data=test_ds, epochs=EPOCHS) _, test_acc = simple_aug_model.evaluate(test_ds) print(\"Test accuracy: {:.2f}%\".format(test_acc * 100)) 391/391 [==============================] - 1169s 3s/step - loss: 1.7628 - accuracy: 0.3862 - val_loss: 1.3458 - val_accuracy: 0.5305 79/79 [==============================] - 42s 527ms/step - loss: 1.3458 - accuracy: 0.5305 Test accuracy: 53.05% Load the CIFAR-10-C dataset and evaluate performance # Load and prepare the CIFAR-10-C dataset # (If it's not already downloaded, it takes ~10 minutes of time to download) cifar_10_c = tfds.load(\"cifar10_corrupted/saturate_5\", split=\"test\", as_supervised=True) cifar_10_c = cifar_10_c.batch(BATCH_SIZE).map( lambda x, y: (tf.image.resize(x, (IMAGE_SIZE, IMAGE_SIZE)), y), num_parallel_calls=AUTO, ) # Evaluate `rand_aug_model` _, test_acc = rand_aug_model.evaluate(cifar_10_c, verbose=0) print( \"Accuracy with RandAugment on CIFAR-10-C (saturate_5): {:.2f}%\".format( test_acc * 100 ) ) # Evaluate `simple_aug_model` _, test_acc = simple_aug_model.evaluate(cifar_10_c, verbose=0) print( \"Accuracy with simple_aug on CIFAR-10-C (saturate_5): {:.2f}%\".format( test_acc * 100 ) ) Accuracy with RandAugment on CIFAR-10-C (saturate_5): 35.90% Accuracy with simple_aug on CIFAR-10-C (saturate_5): 47.34% For the purpose of this example, we trained the models for only a single epoch. On the CIFAR-10-C dataset, the model with RandAugment can perform better with a higher accuracy (for example, 76.64% in one experiment) compared with the model trained with simple_aug (e.g., 64.80%). RandAugment can also help stabilize the training. You can explore this notebook to check some of the results. In the notebook, you may notice that, at the expense of increased training time with RandAugment, we are able to carve out far better performance on the CIFAR-10-C dataset. You can experiment on the other corruption and perturbation settings that come with the run the same CIFAR-10-C dataset and see if RandAugment helps. You can also experiment with the different values of n and m in the RandAugment object. In the original paper, the authors show the impact of the individual augmentation transforms for a particular task and a range of ablation studies. You are welcome to check them out. RandAugment has shown great progress in improving the robustness of deep models for computer vision as shown in works like Noisy Student Training and FixMatch. This makes RandAugment quite a useful recipe for training different vision models. Implementation of NNCLR, a self-supervised learning method for computer vision. Introduction Self-supervised learning Self-supervised representation learning aims to obtain robust representations of samples from raw data without expensive labels or annotations. Early methods in this field focused on defining pretraining tasks which involved a surrogate task on a domain with ample weak supervision labels. Encoders trained to solve such tasks are expected to learn general features that might be useful for other downstream tasks requiring expensive annotations like image classification. Contrastive Learning A broad category of self-supervised learning techniques are those that use contrastive losses, which have been used in a wide range of computer vision applications like image similarity, dimensionality reduction (DrLIM) and face verification/identification. These methods learn a latent space that clusters positive samples together while pushing apart negative samples. NNCLR In this example, we implement NNCLR as proposed in the paper With a Little Help from My Friends: Nearest-Neighbor Contrastive Learning of Visual Representations, by Google Research and DeepMind. NNCLR learns self-supervised representations that go beyond single-instance positives, which allows for learning better features that are invariant to different viewpoints, deformations, and even intra-class variations. Clustering based methods offer a great approach to go beyond single instance positives, but assuming the entire cluster to be positives could hurt performance due to early over-generalization. Instead, NNCLR uses nearest neighbors in the learned representation space as positives. In addition, NNCLR increases the performance of existing contrastive learning methods like SimCLR(Keras Example) and reduces the reliance of self-supervised methods on data augmentation strategies. Here is a great visualization by the paper authors showing how NNCLR builds on ideas from SimCLR: We can see that SimCLR uses two views of the same image as the positive pair. These two views, which are produced using random data augmentations, are fed through an encoder to obtain the positive embedding pair, we end up using two augmentations. NNCLR instead keeps a support set of embeddings representing the full data distribution, and forms the positive pairs using nearest-neighbours. A support set is used as memory during training, similar to a queue (i.e. first-in-first-out) as in MoCo. This example requires TensorFlow 2.6 or higher, as well as tensorflow_datasets, which can be installed with this command: !pip install tensorflow-datasets Requirement already satisfied: tensorflow-datasets in /opt/conda/lib/python3.7/site-packages (4.3.0) Requirement already satisfied: requests>=2.19.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (2.25.1) Requirement already satisfied: typing-extensions in /home/jupyter/.local/lib/python3.7/site-packages (from tensorflow-datasets) (3.7.4.3) Requirement already satisfied: tensorflow-metadata in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (1.2.0) Requirement already satisfied: absl-py in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (0.13.0) Requirement already satisfied: promise in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (2.3) Requirement already satisfied: six in /home/jupyter/.local/lib/python3.7/site-packages (from tensorflow-datasets) (1.15.0) Requirement already satisfied: termcolor in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (1.1.0) Requirement already satisfied: protobuf>=3.12.2 in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (3.16.0) Requirement already satisfied: tqdm in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (4.62.2) Requirement already satisfied: attrs>=18.1.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (21.2.0) Requirement already satisfied: future in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (0.18.2) Requirement already satisfied: dill in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (0.3.4) Requirement already satisfied: importlib-resources in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (5.2.2) Requirement already satisfied: numpy in /opt/conda/lib/python3.7/site-packages (from tensorflow-datasets) (1.19.5) Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.7/site-packages (from requests>=2.19.0->tensorflow-datasets) (2021.5.30) Requirement already satisfied: chardet<5,>=3.0.2 in /opt/conda/lib/python3.7/site-packages (from requests>=2.19.0->tensorflow-datasets) (4.0.0) Requirement already satisfied: idna<3,>=2.5 in /opt/conda/lib/python3.7/site-packages (from requests>=2.19.0->tensorflow-datasets) (2.10) Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.7/site-packages (from requests>=2.19.0->tensorflow-datasets) (1.26.6) Requirement already satisfied: zipp>=3.1.0 in /opt/conda/lib/python3.7/site-packages (from importlib-resources->tensorflow-datasets) (3.5.0) Requirement already satisfied: googleapis-common-protos<2,>=1.52.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow-metadata->tensorflow-datasets) (1.53.0) Collecting absl-py Downloading absl_py-0.12.0-py3-none-any.whl (129 kB)  |████████████████████████████████| 129 kB 8.1 MB/s [?25hInstalling collected packages: absl-py Attempting uninstall: absl-py Found existing installation: absl-py 0.13.0 Uninstalling absl-py-0.13.0: Successfully uninstalled absl-py-0.13.0 ERROR: Could not install packages due to an OSError: [Errno 13] Permission denied: '_flagvalues.cpython-37.pyc' Consider using the `--user` option or check the permissions.  Setup import matplotlib.pyplot as plt import tensorflow as tf import tensorflow_datasets as tfds from tensorflow import keras from tensorflow.keras import layers Hyperparameters A greater queue_size most likely means better performance as shown in the original paper, but introduces significant computational overhead. The authors show that the best results of NNCLR are achieved with a queue size of 98,304 (the largest queue_size they experimented on). We here use 10,000 to show a working example. AUTOTUNE = tf.data.AUTOTUNE shuffle_buffer = 5000 # The below two values are taken from https://www.tensorflow.org/datasets/catalog/stl10 labelled_train_images = 5000 unlabelled_images = 100000 temperature = 0.1 queue_size = 10000 contrastive_augmenter = { \"brightness\": 0.5, \"name\": \"contrastive_augmenter\", \"scale\": (0.2, 1.0), } classification_augmenter = { \"brightness\": 0.2, \"name\": \"classification_augmenter\", \"scale\": (0.5, 1.0), } input_shape = (96, 96, 3) width = 128 num_epochs = 25 steps_per_epoch = 200 Load the Dataset We load the STL-10 dataset from TensorFlow Datasets, an image recognition dataset for developing unsupervised feature learning, deep learning, self-taught learning algorithms. It is inspired by the CIFAR-10 dataset, with some modifications. dataset_name = \"stl10\" def prepare_dataset(): unlabeled_batch_size = unlabelled_images // steps_per_epoch labeled_batch_size = labelled_train_images // steps_per_epoch batch_size = unlabeled_batch_size + labeled_batch_size unlabeled_train_dataset = ( tfds.load( dataset_name, split=\"unlabelled\", as_supervised=True, shuffle_files=True ) .shuffle(buffer_size=shuffle_buffer) .batch(unlabeled_batch_size, drop_remainder=True) ) labeled_train_dataset = ( tfds.load(dataset_name, split=\"train\", as_supervised=True, shuffle_files=True) .shuffle(buffer_size=shuffle_buffer) .batch(labeled_batch_size, drop_remainder=True) ) test_dataset = ( tfds.load(dataset_name, split=\"test\", as_supervised=True) .batch(batch_size) .prefetch(buffer_size=AUTOTUNE) ) train_dataset = tf.data.Dataset.zip( (unlabeled_train_dataset, labeled_train_dataset) ).prefetch(buffer_size=AUTOTUNE) return batch_size, train_dataset, labeled_train_dataset, test_dataset batch_size, train_dataset, labeled_train_dataset, test_dataset = prepare_dataset() Downloading and preparing dataset 2.46 GiB (download: 2.46 GiB, generated: 1.86 GiB, total: 4.32 GiB) to /home/jupyter/tensorflow_datasets/stl10/1.0.0... Dl Completed...: 0 url [00:00, ? url/s] Dl Size...: 0 MiB [00:00, ? MiB/s] Extraction completed...: 0 file [00:00, ? file/s] Generating splits...: 0%| | 0/3 [00:00 device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:04.0, compute capability: 7.0 Shuffling stl10-train.tfrecord...: 0%| | 0/5000 [00:00bik\", tf.expand_dims(anchor_clustering, axis=1), neighbours_clustering ) # similarity shape: [batch_size, k_neighbours] similarity = layers.Lambda(lambda x: tf.squeeze(x, axis=1), name=\"similarity\")( similarity ) # Create the model. model = keras.Model( inputs=[anchor, neighbours], outputs=[similarity, anchor_clustering], name=\"clustering_learner\", ) return model Train model # If tune_encoder_during_clustering is set to False, # then freeze the encoder weights. for layer in encoder.layers: layer.trainable = tune_encoder_during_clustering # Create the clustering model and learner. clustering_model = create_clustering_model(encoder, num_clusters, name=\"clustering\") clustering_learner = create_clustering_learner(clustering_model) # Instantiate the model losses. losses = [ClustersConsistencyLoss(), ClustersEntropyLoss(entropy_loss_weight=5)] # Create the model inputs and labels. inputs = {\"anchors\": x_data, \"neighbours\": tf.gather(x_data, neighbours)} labels = tf.ones(shape=(x_data.shape[0])) # Compile the model. clustering_learner.compile( optimizer=tfa.optimizers.AdamW(learning_rate=0.0005, weight_decay=0.0001), loss=losses, ) # Begin training the model. clustering_learner.fit(x=inputs, y=labels, batch_size=512, epochs=50) Epoch 1/50 118/118 [==============================] - 20s 95ms/step - loss: 0.6655 - similarity_loss: 0.6642 - clustering_loss: 0.0013 Epoch 2/50 118/118 [==============================] - 10s 86ms/step - loss: 0.6361 - similarity_loss: 0.6325 - clustering_loss: 0.0036 Epoch 3/50 118/118 [==============================] - 10s 85ms/step - loss: 0.6129 - similarity_loss: 0.6070 - clustering_loss: 0.0059 Epoch 4/50 118/118 [==============================] - 10s 85ms/step - loss: 0.6005 - similarity_loss: 0.5930 - clustering_loss: 0.0075 Epoch 5/50 118/118 [==============================] - 10s 85ms/step - loss: 0.5923 - similarity_loss: 0.5849 - clustering_loss: 0.0074 Epoch 6/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5879 - similarity_loss: 0.5795 - clustering_loss: 0.0084 Epoch 7/50 118/118 [==============================] - 10s 85ms/step - loss: 0.5841 - similarity_loss: 0.5754 - clustering_loss: 0.0087 Epoch 8/50 118/118 [==============================] - 10s 85ms/step - loss: 0.5817 - similarity_loss: 0.5733 - clustering_loss: 0.0084 Epoch 9/50 118/118 [==============================] - 10s 85ms/step - loss: 0.5811 - similarity_loss: 0.5717 - clustering_loss: 0.0094 Epoch 10/50 118/118 [==============================] - 10s 85ms/step - loss: 0.5797 - similarity_loss: 0.5697 - clustering_loss: 0.0100 Epoch 11/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5767 - similarity_loss: 0.5676 - clustering_loss: 0.0091 Epoch 12/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5771 - similarity_loss: 0.5667 - clustering_loss: 0.0104 Epoch 13/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5755 - similarity_loss: 0.5661 - clustering_loss: 0.0094 Epoch 14/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5746 - similarity_loss: 0.5653 - clustering_loss: 0.0093 Epoch 15/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5743 - similarity_loss: 0.5640 - clustering_loss: 0.0103 Epoch 16/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5738 - similarity_loss: 0.5636 - clustering_loss: 0.0102 Epoch 17/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5732 - similarity_loss: 0.5627 - clustering_loss: 0.0106 Epoch 18/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5723 - similarity_loss: 0.5621 - clustering_loss: 0.0102 Epoch 19/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5711 - similarity_loss: 0.5615 - clustering_loss: 0.0096 Epoch 20/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5693 - similarity_loss: 0.5596 - clustering_loss: 0.0097 Epoch 21/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5699 - similarity_loss: 0.5600 - clustering_loss: 0.0099 Epoch 22/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5694 - similarity_loss: 0.5592 - clustering_loss: 0.0102 Epoch 23/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5703 - similarity_loss: 0.5595 - clustering_loss: 0.0108 Epoch 24/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5687 - similarity_loss: 0.5587 - clustering_loss: 0.0101 Epoch 25/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5688 - similarity_loss: 0.5585 - clustering_loss: 0.0103 Epoch 26/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5690 - similarity_loss: 0.5583 - clustering_loss: 0.0108 Epoch 27/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5679 - similarity_loss: 0.5572 - clustering_loss: 0.0107 Epoch 28/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5681 - similarity_loss: 0.5573 - clustering_loss: 0.0108 Epoch 29/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5682 - similarity_loss: 0.5572 - clustering_loss: 0.0111 Epoch 30/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5675 - similarity_loss: 0.5571 - clustering_loss: 0.0104 Epoch 31/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5679 - similarity_loss: 0.5562 - clustering_loss: 0.0116 Epoch 32/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5663 - similarity_loss: 0.5554 - clustering_loss: 0.0109 Epoch 33/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5665 - similarity_loss: 0.5556 - clustering_loss: 0.0109 Epoch 34/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5679 - similarity_loss: 0.5568 - clustering_loss: 0.0111 Epoch 35/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5680 - similarity_loss: 0.5563 - clustering_loss: 0.0117 Epoch 36/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5665 - similarity_loss: 0.5553 - clustering_loss: 0.0112 Epoch 37/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5674 - similarity_loss: 0.5556 - clustering_loss: 0.0118 Epoch 38/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5648 - similarity_loss: 0.5543 - clustering_loss: 0.0105 Epoch 39/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5653 - similarity_loss: 0.5549 - clustering_loss: 0.0103 Epoch 40/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5656 - similarity_loss: 0.5544 - clustering_loss: 0.0113 Epoch 41/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5644 - similarity_loss: 0.5542 - clustering_loss: 0.0102 Epoch 42/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5658 - similarity_loss: 0.5540 - clustering_loss: 0.0118 Epoch 43/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5655 - similarity_loss: 0.5539 - clustering_loss: 0.0116 Epoch 44/50 118/118 [==============================] - 10s 87ms/step - loss: 0.5662 - similarity_loss: 0.5543 - clustering_loss: 0.0119 Epoch 45/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5651 - similarity_loss: 0.5537 - clustering_loss: 0.0114 Epoch 46/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5635 - similarity_loss: 0.5534 - clustering_loss: 0.0101 Epoch 47/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5633 - similarity_loss: 0.5529 - clustering_loss: 0.0103 Epoch 48/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5643 - similarity_loss: 0.5526 - clustering_loss: 0.0117 Epoch 49/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5653 - similarity_loss: 0.5532 - clustering_loss: 0.0121 Epoch 50/50 118/118 [==============================] - 10s 86ms/step - loss: 0.5641 - similarity_loss: 0.5525 - clustering_loss: 0.0117 Plot training loss plt.plot(history.history[\"loss\"]) plt.ylabel(\"loss\") plt.xlabel(\"epoch\") plt.show() png Cluster analysis Assign images to clusters # Get the cluster probability distribution of the input images. clustering_probs = clustering_model.predict(x_data, batch_size=batch_size, verbose=1) # Get the cluster of the highest probability. cluster_assignments = tf.math.argmax(clustering_probs, axis=-1).numpy() # Store the clustering confidence. # Images with the highest clustering confidence are considered the 'prototypes' # of the clusters. cluster_confidence = tf.math.reduce_max(clustering_probs, axis=-1).numpy() 120/120 [==============================] - 3s 20ms/step Let's compute the cluster sizes clusters = defaultdict(list) for idx, c in enumerate(cluster_assignments): clusters[c].append((idx, cluster_confidence[idx])) for c in range(num_clusters): print(\"cluster\", c, \":\", len(clusters[c])) cluster 0 : 4132 cluster 1 : 4057 cluster 2 : 1713 cluster 3 : 2801 cluster 4 : 2511 cluster 5 : 2655 cluster 6 : 2517 cluster 7 : 4493 cluster 8 : 3687 cluster 9 : 1716 cluster 10 : 3397 cluster 11 : 3606 cluster 12 : 3325 cluster 13 : 4010 cluster 14 : 2188 cluster 15 : 3278 cluster 16 : 1902 cluster 17 : 1858 cluster 18 : 3828 cluster 19 : 2326 Notice that the clusters have roughly balanced sizes. Visualize cluster images Display the prototypes—instances with the highest clustering confidence—of each cluster: num_images = 8 plt.figure(figsize=(15, 15)) position = 1 for c in range(num_clusters): cluster_instances = sorted(clusters[c], key=lambda kv: kv[1], reverse=True) for j in range(num_images): image_idx = cluster_instances[j][0] plt.subplot(num_clusters, num_images, position) plt.imshow(x_data[image_idx].astype(\"uint8\")) plt.title(classes[y_data[image_idx][0]]) plt.axis(\"off\") position += 1 png Compute clustering accuracy First, we assign a label for each cluster based on the majority label of its images. Then, we compute the accuracy of each cluster by dividing the number of image with the majority label by the size of the cluster. cluster_label_counts = dict() for c in range(num_clusters): cluster_label_counts[c] = [0] * num_classes instances = clusters[c] for i, _ in instances: cluster_label_counts[c][y_data[i][0]] += 1 cluster_label_idx = np.argmax(cluster_label_counts[c]) correct_count = np.max(cluster_label_counts[c]) cluster_size = len(clusters[c]) accuracy = ( np.round((correct_count / cluster_size) * 100, 2) if cluster_size > 0 else 0 ) cluster_label = classes[cluster_label_idx] print(\"cluster\", c, \"label is:\", cluster_label, \" - accuracy:\", accuracy, \"%\") cluster 0 label is: frog - accuracy: 23.11 % cluster 1 label is: truck - accuracy: 23.56 % cluster 2 label is: bird - accuracy: 29.01 % cluster 3 label is: dog - accuracy: 16.67 % cluster 4 label is: truck - accuracy: 27.8 % cluster 5 label is: ship - accuracy: 36.91 % cluster 6 label is: deer - accuracy: 27.89 % cluster 7 label is: dog - accuracy: 23.84 % cluster 8 label is: airplane - accuracy: 21.7 % cluster 9 label is: bird - accuracy: 22.38 % cluster 10 label is: automobile - accuracy: 24.76 % cluster 11 label is: automobile - accuracy: 24.15 % cluster 12 label is: cat - accuracy: 17.44 % cluster 13 label is: truck - accuracy: 23.44 % cluster 14 label is: ship - accuracy: 31.67 % cluster 15 label is: airplane - accuracy: 41.06 % cluster 16 label is: deer - accuracy: 22.77 % cluster 17 label is: airplane - accuracy: 15.18 % cluster 18 label is: frog - accuracy: 33.31 % cluster 19 label is: deer - accuracy: 18.7 % Conclusion To improve the accuracy results, you can: 1) increase the number of epochs in the representation learning and the clustering phases; 2) allow the encoder weights to be tuned during the clustering phase; and 3) perform a final fine-tuning step through self-labeling, as described in the original SCAN paper. Note that unsupervised image clustering techniques are not expected to outperform the accuracy of supervised image classification techniques, rather showing that they can learn the semantics of the images and group them into clusters that are similar to their original classes. Contrastive pretraining with SimCLR for semi-supervised image classification on the STL-10 dataset. Introduction Semi-supervised learning Semi-supervised learning is a machine learning paradigm that deals with partially labeled datasets. When applying deep learning in the real world, one usually has to gather a large dataset to make it work well. However, while the cost of labeling scales linearly with the dataset size (labeling each example takes a constant time), model performance only scales sublinearly with it. This means that labeling more and more samples becomes less and less cost-efficient, while gathering unlabeled data is generally cheap, as it is usually readily available in large quantities. Semi-supervised learning offers to solve this problem by only requiring a partially labeled dataset, and by being label-efficient by utilizing the unlabeled examples for learning as well. In this example, we will pretrain an encoder with contrastive learning on the STL-10 semi-supervised dataset using no labels at all, and then fine-tune it using only its labeled subset. Contrastive learning On the highest level, the main idea behind contrastive learning is to learn representations that are invariant to image augmentations in a self-supervised manner. One problem with this objective is that it has a trivial degenerate solution: the case where the representations are constant, and do not depend at all on the input images. Contrastive learning avoids this trap by modifying the objective in the following way: it pulls representations of augmented versions/views of the same image closer to each other (contracting positives), while simultaneously pushing different images away from each other (contrasting negatives) in representation space. One such contrastive approach is SimCLR, which essentially identifies the core components needed to optimize this objective, and can achieve high performance by scaling this simple approach. Another approach is SimSiam (Keras example), whose main difference from SimCLR is that the former does not use any negatives in its loss. Therefore, it does not explicitly prevent the trivial solution, and, instead, avoids it implicitly by architecture design (asymmetric encoding paths using a predictor network and batch normalization (BatchNorm) are applied in the final layers). For further reading about SimCLR, check out the official Google AI blog post, and for an overview of self-supervised learning across both vision and language check out this blog post. Setup import matplotlib.pyplot as plt import tensorflow as tf import tensorflow_datasets as tfds from tensorflow import keras from tensorflow.keras import layers Hyperparameter setup # Dataset hyperparameters unlabeled_dataset_size = 100000 labeled_dataset_size = 5000 image_size = 96 image_channels = 3 # Algorithm hyperparameters num_epochs = 20 batch_size = 525 # Corresponds to 200 steps per epoch width = 128 temperature = 0.1 # Stronger augmentations for contrastive, weaker ones for supervised training contrastive_augmentation = {\"min_area\": 0.25, \"brightness\": 0.6, \"jitter\": 0.2} classification_augmentation = {\"min_area\": 0.75, \"brightness\": 0.3, \"jitter\": 0.1} Dataset During training we will simultaneously load a large batch of unlabeled images along with a smaller batch of labeled images. def prepare_dataset(): # Labeled and unlabeled samples are loaded synchronously # with batch sizes selected accordingly steps_per_epoch = (unlabeled_dataset_size + labeled_dataset_size) // batch_size unlabeled_batch_size = unlabeled_dataset_size // steps_per_epoch labeled_batch_size = labeled_dataset_size // steps_per_epoch print( f\"batch size is {unlabeled_batch_size} (unlabeled) + {labeled_batch_size} (labeled)\" ) unlabeled_train_dataset = ( tfds.load(\"stl10\", split=\"unlabelled\", as_supervised=True, shuffle_files=True) .shuffle(buffer_size=10 * unlabeled_batch_size) .batch(unlabeled_batch_size) ) labeled_train_dataset = ( tfds.load(\"stl10\", split=\"train\", as_supervised=True, shuffle_files=True) .shuffle(buffer_size=10 * labeled_batch_size) .batch(labeled_batch_size) ) test_dataset = ( tfds.load(\"stl10\", split=\"test\", as_supervised=True) .batch(batch_size) .prefetch(buffer_size=tf.data.AUTOTUNE) ) # Labeled and unlabeled datasets are zipped together train_dataset = tf.data.Dataset.zip( (unlabeled_train_dataset, labeled_train_dataset) ).prefetch(buffer_size=tf.data.AUTOTUNE) return train_dataset, labeled_train_dataset, test_dataset # Load STL10 dataset train_dataset, labeled_train_dataset, test_dataset = prepare_dataset() batch size is 500 (unlabeled) + 25 (labeled) Image augmentations The two most important image augmentations for contrastive learning are the following: Cropping: forces the model to encode different parts of the same image similarly, we implement it with the RandomTranslation and RandomZoom layers Color jitter: prevents a trivial color histogram-based solution to the task by distorting color histograms. A principled way to implement that is by affine transformations in color space. In this example we use random horizontal flips as well. Stronger augmentations are applied for contrastive learning, along with weaker ones for supervised classification to avoid overfitting on the few labeled examples. We implement random color jitter as a custom preprocessing layer. Using preprocessing layers for data augmentation has the following two advantages: The data augmentation will run on GPU in batches, so the training will not be bottlenecked by the data pipeline in environments with constrained CPU resources (such as a Colab Notebook, or a personal machine) Deployment is easier as the data preprocessing pipeline is encapsulated in the model, and does not have to be reimplemented when deploying it # Distorts the color distibutions of images class RandomColorAffine(layers.Layer): def __init__(self, brightness=0, jitter=0, **kwargs): super().__init__(**kwargs) self.brightness = brightness self.jitter = jitter def call(self, images, training=True): if training: batch_size = tf.shape(images)[0] # Same for all colors brightness_scales = 1 + tf.random.uniform( (batch_size, 1, 1, 1), minval=-self.brightness, maxval=self.brightness ) # Different for all colors jitter_matrices = tf.random.uniform( (batch_size, 1, 3, 3), minval=-self.jitter, maxval=self.jitter ) color_transforms = ( tf.eye(3, batch_shape=[batch_size, 1]) * brightness_scales + jitter_matrices ) images = tf.clip_by_value(tf.matmul(images, color_transforms), 0, 1) return images # Image augmentation module def get_augmenter(min_area, brightness, jitter): zoom_factor = 1.0 - tf.sqrt(min_area) return keras.Sequential( [ keras.Input(shape=(image_size, image_size, image_channels)), layers.Rescaling(1 / 255), layers.RandomFlip(\"horizontal\"), layers.RandomTranslation(zoom_factor / 2, zoom_factor / 2), layers.RandomZoom((-zoom_factor, 0.0), (-zoom_factor, 0.0)), RandomColorAffine(brightness, jitter), ] ) def visualize_augmentations(num_images): # Sample a batch from a dataset images = next(iter(train_dataset))[0][0][:num_images] # Apply augmentations augmented_images = zip( images, get_augmenter(**classification_augmentation)(images), get_augmenter(**contrastive_augmentation)(images), get_augmenter(**contrastive_augmentation)(images), ) row_titles = [ \"Original:\", \"Weakly augmented:\", \"Strongly augmented:\", \"Strongly augmented:\", ] plt.figure(figsize=(num_images * 2.2, 4 * 2.2), dpi=100) for column, image_row in enumerate(augmented_images): for row, image in enumerate(image_row): plt.subplot(4, num_images, row * num_images + column + 1) plt.imshow(image) if column == 0: plt.title(row_titles[row], loc=\"left\") plt.axis(\"off\") plt.tight_layout() visualize_augmentations(num_images=8) png Encoder architecture # Define the encoder architecture def get_encoder(): return keras.Sequential( [ keras.Input(shape=(image_size, image_size, image_channels)), layers.Conv2D(width, kernel_size=3, strides=2, activation=\"relu\"), layers.Conv2D(width, kernel_size=3, strides=2, activation=\"relu\"), layers.Conv2D(width, kernel_size=3, strides=2, activation=\"relu\"), layers.Conv2D(width, kernel_size=3, strides=2, activation=\"relu\"), layers.Flatten(), layers.Dense(width, activation=\"relu\"), ], name=\"encoder\", ) Supervised baseline model A baseline supervised model is trained using random initialization. # Baseline supervised training with random initialization baseline_model = keras.Sequential( [ keras.Input(shape=(image_size, image_size, image_channels)), get_augmenter(**classification_augmentation), get_encoder(), layers.Dense(10), ], name=\"baseline_model\", ) baseline_model.compile( optimizer=keras.optimizers.Adam(), loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[keras.metrics.SparseCategoricalAccuracy(name=\"acc\")], ) baseline_history = baseline_model.fit( labeled_train_dataset, epochs=num_epochs, validation_data=test_dataset ) print( \"Maximal validation accuracy: {:.2f}%\".format( max(baseline_history.history[\"val_acc\"]) * 100 ) ) Epoch 1/20 200/200 [==============================] - 8s 26ms/step - loss: 2.1769 - acc: 0.1794 - val_loss: 1.7424 - val_acc: 0.3341 Epoch 2/20 200/200 [==============================] - 3s 16ms/step - loss: 1.8366 - acc: 0.3139 - val_loss: 1.6184 - val_acc: 0.3989 Epoch 3/20 200/200 [==============================] - 3s 16ms/step - loss: 1.6331 - acc: 0.3912 - val_loss: 1.5344 - val_acc: 0.4125 Epoch 4/20 200/200 [==============================] - 3s 16ms/step - loss: 1.5439 - acc: 0.4216 - val_loss: 1.4052 - val_acc: 0.4712 Epoch 5/20 200/200 [==============================] - 4s 17ms/step - loss: 1.4576 - acc: 0.4575 - val_loss: 1.4337 - val_acc: 0.4729 Epoch 6/20 200/200 [==============================] - 3s 17ms/step - loss: 1.3723 - acc: 0.4875 - val_loss: 1.4054 - val_acc: 0.4746 Epoch 7/20 200/200 [==============================] - 3s 17ms/step - loss: 1.3445 - acc: 0.5066 - val_loss: 1.3030 - val_acc: 0.5200 Epoch 8/20 200/200 [==============================] - 3s 17ms/step - loss: 1.3015 - acc: 0.5255 - val_loss: 1.2720 - val_acc: 0.5378 Epoch 9/20 200/200 [==============================] - 3s 16ms/step - loss: 1.2244 - acc: 0.5452 - val_loss: 1.3211 - val_acc: 0.5220 Epoch 10/20 200/200 [==============================] - 3s 17ms/step - loss: 1.2204 - acc: 0.5494 - val_loss: 1.2898 - val_acc: 0.5381 Epoch 11/20 200/200 [==============================] - 4s 17ms/step - loss: 1.1359 - acc: 0.5766 - val_loss: 1.2138 - val_acc: 0.5648 Epoch 12/20 200/200 [==============================] - 3s 17ms/step - loss: 1.1228 - acc: 0.5855 - val_loss: 1.2602 - val_acc: 0.5429 Epoch 13/20 200/200 [==============================] - 3s 17ms/step - loss: 1.0853 - acc: 0.6000 - val_loss: 1.2716 - val_acc: 0.5591 Epoch 14/20 200/200 [==============================] - 3s 17ms/step - loss: 1.0632 - acc: 0.6078 - val_loss: 1.2832 - val_acc: 0.5591 Epoch 15/20 200/200 [==============================] - 3s 16ms/step - loss: 1.0268 - acc: 0.6157 - val_loss: 1.1712 - val_acc: 0.5882 Epoch 16/20 200/200 [==============================] - 3s 17ms/step - loss: 0.9594 - acc: 0.6440 - val_loss: 1.2904 - val_acc: 0.5573 Epoch 17/20 200/200 [==============================] - 3s 17ms/step - loss: 0.9524 - acc: 0.6517 - val_loss: 1.1854 - val_acc: 0.5955 Epoch 18/20 200/200 [==============================] - 3s 17ms/step - loss: 0.9118 - acc: 0.6672 - val_loss: 1.1974 - val_acc: 0.5845 Epoch 19/20 200/200 [==============================] - 3s 17ms/step - loss: 0.9187 - acc: 0.6686 - val_loss: 1.1703 - val_acc: 0.6025 Epoch 20/20 200/200 [==============================] - 3s 17ms/step - loss: 0.8520 - acc: 0.6911 - val_loss: 1.1312 - val_acc: 0.6149 Maximal validation accuracy: 61.49% Self-supervised model for contrastive pretraining We pretrain an encoder on unlabeled images with a contrastive loss. A nonlinear projection head is attached to the top of the encoder, as it improves the quality of representations of the encoder. We use the InfoNCE/NT-Xent/N-pairs loss, which can be interpreted in the following way: We treat each image in the batch as if it had its own class. Then, we have two examples (a pair of augmented views) for each \"class\". Each view's representation is compared to every possible pair's one (for both augmented versions). We use the temperature-scaled cosine similarity of compared representations as logits. Finally, we use categorical cross-entropy as the \"classification\" loss The following two metrics are used for monitoring the pretraining performance: Contrastive accuracy (SimCLR Table 5): Self-supervised metric, the ratio of cases in which the representation of an image is more similar to its differently augmented version's one, than to the representation of any other image in the current batch. Self-supervised metrics can be used for hyperparameter tuning even in the case when there are no labeled examples. Linear probing accuracy: Linear probing is a popular metric to evaluate self-supervised classifiers. It is computed as the accuracy of a logistic regression classifier trained on top of the encoder's features. In our case, this is done by training a single dense layer on top of the frozen encoder. Note that contrary to traditional approach where the classifier is trained after the pretraining phase, in this example we train it during pretraining. This might slightly decrease its accuracy, but that way we can monitor its value during training, which helps with experimentation and debugging. Another widely used supervised metric is the KNN accuracy, which is the accuracy of a KNN classifier trained on top of the encoder's features, which is not implemented in this example. # Define the contrastive model with model-subclassing class ContrastiveModel(keras.Model): def __init__(self): super().__init__() self.temperature = temperature self.contrastive_augmenter = get_augmenter(**contrastive_augmentation) self.classification_augmenter = get_augmenter(**classification_augmentation) self.encoder = get_encoder() # Non-linear MLP as projection head self.projection_head = keras.Sequential( [ keras.Input(shape=(width,)), layers.Dense(width, activation=\"relu\"), layers.Dense(width), ], name=\"projection_head\", ) # Single dense layer for linear probing self.linear_probe = keras.Sequential( [layers.Input(shape=(width,)), layers.Dense(10)], name=\"linear_probe\" ) self.encoder.summary() self.projection_head.summary() self.linear_probe.summary() def compile(self, contrastive_optimizer, probe_optimizer, **kwargs): super().compile(**kwargs) self.contrastive_optimizer = contrastive_optimizer self.probe_optimizer = probe_optimizer # self.contrastive_loss will be defined as a method self.probe_loss = keras.losses.SparseCategoricalCrossentropy(from_logits=True) self.contrastive_loss_tracker = keras.metrics.Mean(name=\"c_loss\") self.contrastive_accuracy = keras.metrics.SparseCategoricalAccuracy( name=\"c_acc\" ) self.probe_loss_tracker = keras.metrics.Mean(name=\"p_loss\") self.probe_accuracy = keras.metrics.SparseCategoricalAccuracy(name=\"p_acc\") @property def metrics(self): return [ self.contrastive_loss_tracker, self.contrastive_accuracy, self.probe_loss_tracker, self.probe_accuracy, ] def contrastive_loss(self, projections_1, projections_2): # InfoNCE loss (information noise-contrastive estimation) # NT-Xent loss (normalized temperature-scaled cross entropy) # Cosine similarity: the dot product of the l2-normalized feature vectors projections_1 = tf.math.l2_normalize(projections_1, axis=1) projections_2 = tf.math.l2_normalize(projections_2, axis=1) similarities = ( tf.matmul(projections_1, projections_2, transpose_b=True) / self.temperature ) # The similarity between the representations of two augmented views of the # same image should be higher than their similarity with other views batch_size = tf.shape(projections_1)[0] contrastive_labels = tf.range(batch_size) self.contrastive_accuracy.update_state(contrastive_labels, similarities) self.contrastive_accuracy.update_state( contrastive_labels, tf.transpose(similarities) ) # The temperature-scaled similarities are used as logits for cross-entropy # a symmetrized version of the loss is used here loss_1_2 = keras.losses.sparse_categorical_crossentropy( contrastive_labels, similarities, from_logits=True ) loss_2_1 = keras.losses.sparse_categorical_crossentropy( contrastive_labels, tf.transpose(similarities), from_logits=True ) return (loss_1_2 + loss_2_1) / 2 def train_step(self, data): (unlabeled_images, _), (labeled_images, labels) = data # Both labeled and unlabeled images are used, without labels images = tf.concat((unlabeled_images, labeled_images), axis=0) # Each image is augmented twice, differently augmented_images_1 = self.contrastive_augmenter(images, training=True) augmented_images_2 = self.contrastive_augmenter(images, training=True) with tf.GradientTape() as tape: features_1 = self.encoder(augmented_images_1, training=True) features_2 = self.encoder(augmented_images_2, training=True) # The representations are passed through a projection mlp projections_1 = self.projection_head(features_1, training=True) projections_2 = self.projection_head(features_2, training=True) contrastive_loss = self.contrastive_loss(projections_1, projections_2) gradients = tape.gradient( contrastive_loss, self.encoder.trainable_weights + self.projection_head.trainable_weights, ) self.contrastive_optimizer.apply_gradients( zip( gradients, self.encoder.trainable_weights + self.projection_head.trainable_weights, ) ) self.contrastive_loss_tracker.update_state(contrastive_loss) # Labels are only used in evalutation for an on-the-fly logistic regression preprocessed_images = self.classification_augmenter( labeled_images, training=True ) with tf.GradientTape() as tape: # the encoder is used in inference mode here to avoid regularization # and updating the batch normalization paramers if they are used features = self.encoder(preprocessed_images, training=False) class_logits = self.linear_probe(features, training=True) probe_loss = self.probe_loss(labels, class_logits) gradients = tape.gradient(probe_loss, self.linear_probe.trainable_weights) self.probe_optimizer.apply_gradients( zip(gradients, self.linear_probe.trainable_weights) ) self.probe_loss_tracker.update_state(probe_loss) self.probe_accuracy.update_state(labels, class_logits) return {m.name: m.result() for m in self.metrics} def test_step(self, data): labeled_images, labels = data # For testing the components are used with a training=False flag preprocessed_images = self.classification_augmenter( labeled_images, training=False ) features = self.encoder(preprocessed_images, training=False) class_logits = self.linear_probe(features, training=False) probe_loss = self.probe_loss(labels, class_logits) self.probe_loss_tracker.update_state(probe_loss) self.probe_accuracy.update_state(labels, class_logits) # Only the probe metrics are logged at test time return {m.name: m.result() for m in self.metrics[2:]} # Contrastive pretraining pretraining_model = ContrastiveModel() pretraining_model.compile( contrastive_optimizer=keras.optimizers.Adam(), probe_optimizer=keras.optimizers.Adam(), ) pretraining_history = pretraining_model.fit( train_dataset, epochs=num_epochs, validation_data=test_dataset ) print( \"Maximal validation accuracy: {:.2f}%\".format( max(pretraining_history.history[\"val_p_acc\"]) * 100 ) ) Model: \"encoder\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_4 (Conv2D) (None, 47, 47, 128) 3584 _________________________________________________________________ conv2d_5 (Conv2D) (None, 23, 23, 128) 147584 _________________________________________________________________ conv2d_6 (Conv2D) (None, 11, 11, 128) 147584 _________________________________________________________________ conv2d_7 (Conv2D) (None, 5, 5, 128) 147584 _________________________________________________________________ flatten_1 (Flatten) (None, 3200) 0 _________________________________________________________________ dense_2 (Dense) (None, 128) 409728 ================================================================= Total params: 856,064 Trainable params: 856,064 Non-trainable params: 0 _________________________________________________________________ Model: \"projection_head\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_3 (Dense) (None, 128) 16512 _________________________________________________________________ dense_4 (Dense) (None, 128) 16512 ================================================================= Total params: 33,024 Trainable params: 33,024 Non-trainable params: 0 _________________________________________________________________ Model: \"linear_probe\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_5 (Dense) (None, 10) 1290 ================================================================= Total params: 1,290 Trainable params: 1,290 Non-trainable params: 0 _________________________________________________________________ Epoch 1/20 200/200 [==============================] - 70s 325ms/step - c_loss: 4.7788 - c_acc: 0.1340 - p_loss: 2.2030 - p_acc: 0.1922 - val_p_loss: 2.1043 - val_p_acc: 0.2540 Epoch 2/20 200/200 [==============================] - 67s 323ms/step - c_loss: 3.4836 - c_acc: 0.3047 - p_loss: 2.0159 - p_acc: 0.3030 - val_p_loss: 1.9833 - val_p_acc: 0.3120 Epoch 3/20 200/200 [==============================] - 65s 322ms/step - c_loss: 2.9157 - c_acc: 0.4187 - p_loss: 1.8896 - p_acc: 0.3598 - val_p_loss: 1.8621 - val_p_acc: 0.3556 Epoch 4/20 200/200 [==============================] - 67s 322ms/step - c_loss: 2.5837 - c_acc: 0.4867 - p_loss: 1.7965 - p_acc: 0.3912 - val_p_loss: 1.7400 - val_p_acc: 0.4006 Epoch 5/20 200/200 [==============================] - 67s 322ms/step - c_loss: 2.3462 - c_acc: 0.5403 - p_loss: 1.6961 - p_acc: 0.4138 - val_p_loss: 1.6655 - val_p_acc: 0.4190 Epoch 6/20 200/200 [==============================] - 65s 321ms/step - c_loss: 2.2214 - c_acc: 0.5714 - p_loss: 1.6325 - p_acc: 0.4322 - val_p_loss: 1.6242 - val_p_acc: 0.4366 Epoch 7/20 200/200 [==============================] - 67s 322ms/step - c_loss: 2.0618 - c_acc: 0.6098 - p_loss: 1.5793 - p_acc: 0.4470 - val_p_loss: 1.5348 - val_p_acc: 0.4663 Epoch 8/20 200/200 [==============================] - 65s 322ms/step - c_loss: 1.9532 - c_acc: 0.6360 - p_loss: 1.5173 - p_acc: 0.4652 - val_p_loss: 1.5248 - val_p_acc: 0.4700 Epoch 9/20 200/200 [==============================] - 65s 322ms/step - c_loss: 1.8487 - c_acc: 0.6602 - p_loss: 1.4631 - p_acc: 0.4798 - val_p_loss: 1.4587 - val_p_acc: 0.4905 Epoch 10/20 200/200 [==============================] - 65s 322ms/step - c_loss: 1.7837 - c_acc: 0.6767 - p_loss: 1.4310 - p_acc: 0.4992 - val_p_loss: 1.4265 - val_p_acc: 0.4924 Epoch 11/20 200/200 [==============================] - 65s 321ms/step - c_loss: 1.7133 - c_acc: 0.6955 - p_loss: 1.3764 - p_acc: 0.5090 - val_p_loss: 1.3663 - val_p_acc: 0.5169 Epoch 12/20 200/200 [==============================] - 66s 322ms/step - c_loss: 1.6655 - c_acc: 0.7064 - p_loss: 1.3511 - p_acc: 0.5140 - val_p_loss: 1.3779 - val_p_acc: 0.5071 Epoch 13/20 200/200 [==============================] - 67s 322ms/step - c_loss: 1.6110 - c_acc: 0.7198 - p_loss: 1.3182 - p_acc: 0.5282 - val_p_loss: 1.3259 - val_p_acc: 0.5303 Epoch 14/20 200/200 [==============================] - 66s 321ms/step - c_loss: 1.5727 - c_acc: 0.7312 - p_loss: 1.2965 - p_acc: 0.5308 - val_p_loss: 1.2858 - val_p_acc: 0.5422 Epoch 15/20 200/200 [==============================] - 67s 322ms/step - c_loss: 1.5477 - c_acc: 0.7361 - p_loss: 1.2751 - p_acc: 0.5432 - val_p_loss: 1.2795 - val_p_acc: 0.5472 Epoch 16/20 200/200 [==============================] - 65s 321ms/step - c_loss: 1.5127 - c_acc: 0.7448 - p_loss: 1.2562 - p_acc: 0.5498 - val_p_loss: 1.2731 - val_p_acc: 0.5461 Epoch 17/20 200/200 [==============================] - 67s 321ms/step - c_loss: 1.4811 - c_acc: 0.7517 - p_loss: 1.2306 - p_acc: 0.5574 - val_p_loss: 1.2439 - val_p_acc: 0.5630 Epoch 18/20 200/200 [==============================] - 67s 321ms/step - c_loss: 1.4598 - c_acc: 0.7576 - p_loss: 1.2215 - p_acc: 0.5544 - val_p_loss: 1.2352 - val_p_acc: 0.5623 Epoch 19/20 200/200 [==============================] - 65s 321ms/step - c_loss: 1.4349 - c_acc: 0.7631 - p_loss: 1.2161 - p_acc: 0.5662 - val_p_loss: 1.2670 - val_p_acc: 0.5479 Epoch 20/20 200/200 [==============================] - 66s 321ms/step - c_loss: 1.4159 - c_acc: 0.7691 - p_loss: 1.2044 - p_acc: 0.5656 - val_p_loss: 1.2204 - val_p_acc: 0.5624 Maximal validation accuracy: 56.30% Supervised finetuning of the pretrained encoder We then finetune the encoder on the labeled examples, by attaching a single randomly initalized fully connected classification layer on its top. # Supervised finetuning of the pretrained encoder finetuning_model = keras.Sequential( [ layers.Input(shape=(image_size, image_size, image_channels)), get_augmenter(**classification_augmentation), pretraining_model.encoder, layers.Dense(10), ], name=\"finetuning_model\", ) finetuning_model.compile( optimizer=keras.optimizers.Adam(), loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[keras.metrics.SparseCategoricalAccuracy(name=\"acc\")], ) finetuning_history = finetuning_model.fit( labeled_train_dataset, epochs=num_epochs, validation_data=test_dataset ) print( \"Maximal validation accuracy: {:.2f}%\".format( max(finetuning_history.history[\"val_acc\"]) * 100 ) ) Epoch 1/20 200/200 [==============================] - 4s 17ms/step - loss: 1.9942 - acc: 0.2554 - val_loss: 1.4278 - val_acc: 0.4647 Epoch 2/20 200/200 [==============================] - 3s 16ms/step - loss: 1.5209 - acc: 0.4373 - val_loss: 1.3119 - val_acc: 0.5170 Epoch 3/20 200/200 [==============================] - 3s 17ms/step - loss: 1.3210 - acc: 0.5132 - val_loss: 1.2328 - val_acc: 0.5529 Epoch 4/20 200/200 [==============================] - 3s 17ms/step - loss: 1.1932 - acc: 0.5603 - val_loss: 1.1328 - val_acc: 0.5872 Epoch 5/20 200/200 [==============================] - 3s 17ms/step - loss: 1.1217 - acc: 0.5984 - val_loss: 1.1508 - val_acc: 0.5906 Epoch 6/20 200/200 [==============================] - 3s 16ms/step - loss: 1.0665 - acc: 0.6176 - val_loss: 1.2544 - val_acc: 0.5753 Epoch 7/20 200/200 [==============================] - 3s 16ms/step - loss: 0.9890 - acc: 0.6510 - val_loss: 1.0107 - val_acc: 0.6409 Epoch 8/20 200/200 [==============================] - 3s 16ms/step - loss: 0.9775 - acc: 0.6468 - val_loss: 1.0907 - val_acc: 0.6150 Epoch 9/20 200/200 [==============================] - 3s 17ms/step - loss: 0.9105 - acc: 0.6736 - val_loss: 1.1057 - val_acc: 0.6183 Epoch 10/20 200/200 [==============================] - 3s 17ms/step - loss: 0.8658 - acc: 0.6895 - val_loss: 1.1794 - val_acc: 0.5938 Epoch 11/20 200/200 [==============================] - 3s 17ms/step - loss: 0.8503 - acc: 0.6946 - val_loss: 1.0764 - val_acc: 0.6325 Epoch 12/20 200/200 [==============================] - 3s 17ms/step - loss: 0.7973 - acc: 0.7193 - val_loss: 1.0065 - val_acc: 0.6561 Epoch 13/20 200/200 [==============================] - 3s 16ms/step - loss: 0.7516 - acc: 0.7319 - val_loss: 1.0955 - val_acc: 0.6345 Epoch 14/20 200/200 [==============================] - 3s 16ms/step - loss: 0.7504 - acc: 0.7406 - val_loss: 1.1041 - val_acc: 0.6386 Epoch 15/20 200/200 [==============================] - 3s 16ms/step - loss: 0.7419 - acc: 0.7324 - val_loss: 1.0680 - val_acc: 0.6492 Epoch 16/20 200/200 [==============================] - 3s 17ms/step - loss: 0.7318 - acc: 0.7265 - val_loss: 1.1635 - val_acc: 0.6313 Epoch 17/20 200/200 [==============================] - 3s 17ms/step - loss: 0.6904 - acc: 0.7505 - val_loss: 1.0826 - val_acc: 0.6503 Epoch 18/20 200/200 [==============================] - 3s 17ms/step - loss: 0.6389 - acc: 0.7714 - val_loss: 1.1260 - val_acc: 0.6364 Epoch 19/20 200/200 [==============================] - 3s 16ms/step - loss: 0.6355 - acc: 0.7829 - val_loss: 1.0750 - val_acc: 0.6554 Epoch 20/20 200/200 [==============================] - 3s 17ms/step - loss: 0.6279 - acc: 0.7758 - val_loss: 1.0465 - val_acc: 0.6604 Maximal validation accuracy: 66.04% Comparison against the baseline # The classification accuracies of the baseline and the pretraining + finetuning process: def plot_training_curves(pretraining_history, finetuning_history, baseline_history): for metric_key, metric_name in zip([\"acc\", \"loss\"], [\"accuracy\", \"loss\"]): plt.figure(figsize=(8, 5), dpi=100) plt.plot( baseline_history.history[f\"val_{metric_key}\"], label=\"supervised ba Unifying semi-supervised learning and unsupervised domain adaptation with AdaMatch. Introduction In this example, we will implement the AdaMatch algorithm, proposed in AdaMatch: A Unified Approach to Semi-Supervised Learning and Domain Adaptation by Berthelot et al. It sets a new state-of-the-art in unsupervised domain adaptation (as of June 2021). AdaMatch is particularly interesting because it unifies semi-supervised learning (SSL) and unsupervised domain adaptation (UDA) under one framework. It thereby provides a way to perform semi-supervised domain adaptation (SSDA). This example requires TensorFlow 2.5 or higher, as well as TensorFlow Models, which can be installed using the following command: !pip install -q tf-models-official Before we proceed, let's review a few preliminary concepts underlying this example. Preliminaries In semi-supervised learning (SSL), we use a small amount of labeled data to train models on a bigger unlabeled dataset. Popular semi-supervised learning methods for computer vision include FixMatch, MixMatch, Noisy Student Training, etc. You can refer to this example to get an idea of what a standard SSL workflow looks like. In unsupervised domain adaptation, we have access to a source labeled dataset and a target unlabeled dataset. Then the task is to learn a model that can generalize well to the target dataset. The source and the target datasets vary in terms of distribution. The following figure provides an illustration of this idea. In the present example, we use the MNIST dataset as the source dataset, while the target dataset is SVHN, which consists of images of house numbers. Both datasets have various varying factors in terms of texture, viewpoint, appearence, etc.: their domains, or distributions, are different from one another. Popular domain adaptation algorithms in deep learning include Deep CORAL, Moment Matching, etc. Setup import tensorflow as tf tf.random.set_seed(42) import numpy as np from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras import regularizers from official.vision.image_classification.augment import RandAugment import tensorflow_datasets as tfds tfds.disable_progress_bar() Prepare the data # MNIST ( (mnist_x_train, mnist_y_train), (mnist_x_test, mnist_y_test), ) = keras.datasets.mnist.load_data() # Add a channel dimension mnist_x_train = tf.expand_dims(mnist_x_train, -1) mnist_x_test = tf.expand_dims(mnist_x_test, -1) # Convert the labels to one-hot encoded vectors mnist_y_train = tf.one_hot(mnist_y_train, 10).numpy() # SVHN svhn_train, svhn_test = tfds.load( \"svhn_cropped\", split=[\"train\", \"test\"], as_supervised=True ) Define constants and hyperparameters RESIZE_TO = 32 SOURCE_BATCH_SIZE = 64 TARGET_BATCH_SIZE = 3 * SOURCE_BATCH_SIZE # Reference: Section 3.2 EPOCHS = 10 STEPS_PER_EPOCH = len(mnist_x_train) // SOURCE_BATCH_SIZE TOTAL_STEPS = EPOCHS * STEPS_PER_EPOCH AUTO = tf.data.AUTOTUNE LEARNING_RATE = 0.03 WEIGHT_DECAY = 0.0005 INIT = \"he_normal\" DEPTH = 28 WIDTH_MULT = 2 Data augmentation utilities A standard element of SSL algorithms is to feed weakly and strongly augmented versions of the same images to the learning model to make its predictions consistent. For strong augmentation, RandAugment is a standard choice. For weak augmentation, we will use horizontal flipping and random cropping. # Initialize `RandAugment` object with 2 layers of # augmentation transforms and strength of 5. augmenter = RandAugment(num_layers=2, magnitude=5) def weak_augment(image, source=True): if image.dtype != tf.float32: image = tf.cast(image, tf.float32) # MNIST images are grayscale, this is why we first convert them to # RGB images. if source: image = tf.image.resize_with_pad(image, RESIZE_TO, RESIZE_TO) image = tf.tile(image, [1, 1, 3]) image = tf.image.random_flip_left_right(image) image = tf.image.random_crop(image, (RESIZE_TO, RESIZE_TO, 3)) return image def strong_augment(image, source=True): if image.dtype != tf.float32: image = tf.cast(image, tf.float32) if source: image = tf.image.resize_with_pad(image, RESIZE_TO, RESIZE_TO) image = tf.tile(image, [1, 1, 3]) image = augmenter.distort(image) return image Data loading utilities def create_individual_ds(ds, aug_func, source=True): if source: batch_size = SOURCE_BATCH_SIZE else: # During training 3x more target unlabeled samples are shown # to the model in AdaMatch (Section 3.2 of the paper). batch_size = TARGET_BATCH_SIZE ds = ds.shuffle(batch_size * 10, seed=42) if source: ds = ds.map(lambda x, y: (aug_func(x), y), num_parallel_calls=AUTO) else: ds = ds.map(lambda x, y: (aug_func(x, False), y), num_parallel_calls=AUTO) ds = ds.batch(batch_size).prefetch(AUTO) return ds _w and _s suffixes denote weak and strong respectively. source_ds = tf.data.Dataset.from_tensor_slices((mnist_x_train, mnist_y_train)) source_ds_w = create_individual_ds(source_ds, weak_augment) source_ds_s = create_individual_ds(source_ds, strong_augment) final_source_ds = tf.data.Dataset.zip((source_ds_w, source_ds_s)) target_ds_w = create_individual_ds(svhn_train, weak_augment, source=False) target_ds_s = create_individual_ds(svhn_train, strong_augment, source=False) final_target_ds = tf.data.Dataset.zip((target_ds_w, target_ds_s)) Here's what a single image batch looks like: Loss computation utilities def compute_loss_source(source_labels, logits_source_w, logits_source_s): loss_func = keras.losses.CategoricalCrossentropy(from_logits=True) # First compute the losses between original source labels and # predictions made on the weakly and strongly augmented versions # of the same images. w_loss = loss_func(source_labels, logits_source_w) s_loss = loss_func(source_labels, logits_source_s) return w_loss + s_loss def compute_loss_target(target_pseudo_labels_w, logits_target_s, mask): loss_func = keras.losses.CategoricalCrossentropy(from_logits=True, reduction=\"none\") target_pseudo_labels_w = tf.stop_gradient(target_pseudo_labels_w) # For calculating loss for the target samples, we treat the pseudo labels # as the ground-truth. These are not considered during backpropagation # which is a standard SSL practice. target_loss = loss_func(target_pseudo_labels_w, logits_target_s) # More on `mask` later. mask = tf.cast(mask, target_loss.dtype) target_loss *= mask return tf.reduce_mean(target_loss, 0) Subclassed model for AdaMatch training The figure below presents the overall workflow of AdaMatch (taken from the original paper): Here's a brief step-by-step breakdown of the workflow: We first retrieve the weakly and strongly augmented pairs of images from the source and target datasets. We prepare two concatenated copies: i. One where both pairs are concatenated. ii. One where only the source data image pair is concatenated. We run two forward passes through the model: i. The first forward pass uses the concatenated copy obtained from 2.i. In this forward pass, the Batch Normalization statistics are updated. ii. In the second forward pass, we only use the concatenated copy obtained from 2.ii. Batch Normalization layers are run in inference mode. The respective logits are computed for both the forward passes. The logits go through a series of transformations, introduced in the paper (which we will discuss shortly). We compute the loss and update the gradients of the underlying model. class AdaMatch(keras.Model): def __init__(self, model, total_steps, tau=0.9): super(AdaMatch, self).__init__() self.model = model self.tau = tau # Denotes the confidence threshold self.loss_tracker = tf.keras.metrics.Mean(name=\"loss\") self.total_steps = total_steps self.current_step = tf.Variable(0, dtype=\"int64\") @property def metrics(self): return [self.loss_tracker] # This is a warmup schedule to update the weight of the # loss contributed by the target unlabeled samples. More # on this in the text. def compute_mu(self): pi = tf.constant(np.pi, dtype=\"float32\") step = tf.cast(self.current_step, dtype=\"float32\") return 0.5 - tf.cos(tf.math.minimum(pi, (2 * pi * step) / self.total_steps)) / 2 def train_step(self, data): ## Unpack and organize the data ## source_ds, target_ds = data (source_w, source_labels), (source_s, _) = source_ds ( (target_w, _), (target_s, _), ) = target_ds # Notice that we are NOT using any labels here. combined_images = tf.concat([source_w, source_s, target_w, target_s], 0) combined_source = tf.concat([source_w, source_s], 0) total_source = tf.shape(combined_source)[0] total_target = tf.shape(tf.concat([target_w, target_s], 0))[0] with tf.GradientTape() as tape: ## Forward passes ## combined_logits = self.model(combined_images, training=True) z_d_prime_source = self.model( combined_source, training=False ) # No BatchNorm update. z_prime_source = combined_logits[:total_source] ## 1. Random logit interpolation for the source images ## lambd = tf.random.uniform((total_source, 10), 0, 1) final_source_logits = (lambd * z_prime_source) + ( (1 - lambd) * z_d_prime_source ) ## 2. Distribution alignment (only consider weakly augmented images) ## # Compute softmax for logits of the WEAKLY augmented SOURCE images. y_hat_source_w = tf.nn.softmax(final_source_logits[: tf.shape(source_w)[0]]) # Extract logits for the WEAKLY augmented TARGET images and compute softmax. logits_target = combined_logits[total_source:] logits_target_w = logits_target[: tf.shape(target_w)[0]] y_hat_target_w = tf.nn.softmax(logits_target_w) # Align the target label distribution to that of the source. expectation_ratio = tf.reduce_mean(y_hat_source_w) / tf.reduce_mean( y_hat_target_w ) y_tilde_target_w = tf.math.l2_normalize( y_hat_target_w * expectation_ratio, 1 ) ## 3. Relative confidence thresholding ## row_wise_max = tf.reduce_max(y_hat_source_w, axis=-1) final_sum = tf.reduce_mean(row_wise_max, 0) c_tau = self.tau * final_sum mask = tf.reduce_max(y_tilde_target_w, axis=-1) >= c_tau ## Compute losses (pay attention to the indexing) ## source_loss = compute_loss_source( source_labels, final_source_logits[: tf.shape(source_w)[0]], final_source_logits[tf.shape(source_w)[0] :], ) target_loss = compute_loss_target( y_tilde_target_w, logits_target[tf.shape(target_w)[0] :], mask ) t = self.compute_mu() # Compute weight for the target loss total_loss = source_loss + (t * target_loss) self.current_step.assign_add( 1 ) # Update current training step for the scheduler gradients = tape.gradient(total_loss, self.model.trainable_variables) self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables)) self.loss_tracker.update_state(total_loss) return {\"loss\": self.loss_tracker.result()} The authors introduce three improvements in the paper: In AdaMatch, we perform two forward passes, and only one of them is respsonsible for updating the Batch Normalization statistics. This is done to account for distribution shifts in the target dataset. In the other forward pass, we only use the source sample, and the Batch Normalization layers are run in inference mode. Logits for the source samples (weakly and strongly augmented versions) from these two passes are slightly different from one another because of how Batch Normalization layers are run. Final logits for the source samples are computed by linearly interpolating between these two different pairs of logits. This induces a form of consistency regularization. This step is referred to as random logit interpolation. Distribution alignment is used to align the source and target label distributions. This further helps the underlying model learn domain-invariant representations. In case of unsupervised domain adaptation, we don't have access to any labels of the target dataset. This is why pseudo labels are generated from the underlying model. The underlying model generates pseudo-labels for the target samples. It's likely that the model would make faulty predictions. Those can propagate back as we make progress in the training, and hurt the overall performance. To compensate for that, we filter the high-confidence predictions based on a threshold (hence the use of mask inside compute_loss_target()). In AdaMatch, this threshold is relatively adjusted which is why it is called relative confidence thresholding. For more details on these methods and to know how each of them contribute please refer to the paper. About compute_mu(): Rather than using a fixed scalar quantity, a varying scalar is used in AdaMatch. It denotes the weight of the loss contibuted by the target samples. Visually, the weight scheduler look like so: This scheduler increases the weight of the target domain loss from 0 to 1 for the first half of the training. Then it keeps that weight at 1 for the second half of the training. Instantiate a Wide-ResNet-28-2 The authors use a WideResNet-28-2 for the dataset pairs we are using in this example. Most of the following code has been referred from this script. Note that the following model has a scaling layer inside it that scales the pixel values to [0, 1]. def wide_basic(x, n_input_plane, n_output_plane, stride): conv_params = [[3, 3, stride, \"same\"], [3, 3, (1, 1), \"same\"]] n_bottleneck_plane = n_output_plane # Residual block for i, v in enumerate(conv_params): if i == 0: if n_input_plane != n_output_plane: x = layers.BatchNormalization()(x) x = layers.Activation(\"relu\")(x) convs = x else: convs = layers.BatchNormalization()(x) convs = layers.Activation(\"relu\")(convs) convs = layers.Conv2D( n_bottleneck_plane, (v[0], v[1]), strides=v[2], padding=v[3], kernel_initializer=INIT, kernel_regularizer=regularizers.l2(WEIGHT_DECAY), use_bias=False, )(convs) else: convs = layers.BatchNormalization()(convs) convs = layers.Activation(\"relu\")(convs) convs = layers.Conv2D( n_bottleneck_plane, (v[0], v[1]), strides=v[2], padding=v[3], kernel_initializer=INIT, kernel_regularizer=regularizers.l2(WEIGHT_DECAY), use_bias=False, )(convs) # Shortcut connection: identity function or 1x1 # convolutional # (depends on difference between input & output shape - this # corresponds to whether we are using the first block in # each # group; see `block_series()`). if n_input_plane != n_output_plane: shortcut = layers.Conv2D( n_output_plane, (1, 1), strides=stride, padding=\"same\", kernel_initializer=INIT, kernel_regularizer=regularizers.l2(WEIGHT_DECAY), use_bias=False, )(x) else: shortcut = x return layers.Add()([convs, shortcut]) # Stacking residual units on the same stage def block_series(x, n_input_plane, n_output_plane, count, stride): x = wide_basic(x, n_input_plane, n_output_plane, stride) for i in range(2, int(count + 1)): x = wide_basic(x, n_output_plane, n_output_plane, stride=1) return x def get_network(image_size=32, num_classes=10): n = (DEPTH - 4) / 6 n_stages = [16, 16 * WIDTH_MULT, 32 * WIDTH_MULT, 64 * WIDTH_MULT] inputs = keras.Input(shape=(image_size, image_size, 3)) x = layers.Rescaling(scale=1.0 / 255)(inputs) conv1 = layers.Conv2D( n_stages[0], (3, 3), strides=1, padding=\"same\", kernel_initializer=INIT, kernel_regularizer=regularizers.l2(WEIGHT_DECAY), use_bias=False, )(x) ## Add wide residual blocks ## conv2 = block_series( conv1, n_input_plane=n_stages[0], n_output_plane=n_stages[1], count=n, stride=(1, 1), ) # Stage 1 conv3 = block_series( conv2, n_input_plane=n_stages[1], n_output_plane=n_stages[2], count=n, stride=(2, 2), ) # Stage 2 conv4 = block_series( conv3, n_input_plane=n_stages[2], n_output_plane=n_stages[3], count=n, stride=(2, 2), ) # Stage 3 batch_norm = layers.BatchNormalization()(conv4) relu = layers.Activation(\"relu\")(batch_norm) # Classifier trunk_outputs = layers.GlobalAveragePooling2D()(relu) outputs = layers.Dense( num_classes, kernel_regularizer=regularizers.l2(WEIGHT_DECAY) )(trunk_outputs) return keras.Model(inputs, outputs) We can now instantiate a Wide ResNet model like so. Note that the purpose of using a Wide ResNet here is to keep the implementation as close to the original one as possible. wrn_model = get_network() print(f\"Model has {wrn_model.count_params()/1e6} Million parameters.\") Model has 1.471226 Million parameters. Instantiate AdaMatch model and compile it reduce_lr = keras.optimizers.schedules.CosineDecay(LEARNING_RATE, TOTAL_STEPS, 0.25) optimizer = keras.optimizers.Adam(reduce_lr) adamatch_trainer = AdaMatch(model=wrn_model, total_steps=TOTAL_STEPS) adamatch_trainer.compile(optimizer=optimizer) Model training total_ds = tf.data.Dataset.zip((final_source_ds, final_target_ds)) adamatch_trainer.fit(total_ds, epochs=EPOCHS) Epoch 1/10 382/382 [==============================] - 53s 96ms/step - loss: 117866954752.0000 Epoch 2/10 382/382 [==============================] - 36s 95ms/step - loss: 2.6231 Epoch 3/10 382/382 [==============================] - 36s 94ms/step - loss: 4.1699 Epoch 4/10 382/382 [==============================] - 36s 95ms/step - loss: 8.2748 Epoch 5/10 382/382 [==============================] - 36s 95ms/step - loss: 28.8679 Epoch 6/10 382/382 [==============================] - 36s 94ms/step - loss: 14.7112 Epoch 7/10 382/382 [==============================] - 36s 94ms/step - loss: 7.8206 Epoch 8/10 382/382 [==============================] - 36s 94ms/step - loss: 18.1182 Epoch 9/10 382/382 [==============================] - 36s 94ms/step - loss: 22.4258 Epoch 10/10 382/382 [==============================] - 36s 95ms/step - loss: 22.1107 Evaluation on the target and source test sets # Compile the AdaMatch model to yield accuracy. adamatch_trained_model = adamatch_trainer.model adamatch_trained_model.compile(metrics=keras.metrics.SparseCategoricalAccuracy()) # Score on the target test set. svhn_test = svhn_test.batch(TARGET_BATCH_SIZE).prefetch(AUTO) _, accuracy = adamatch_trained_model.evaluate(svhn_test) print(f\"Accuracy on target test set: {accuracy * 100:.2f}%\") 136/136 [==============================] - 2s 10ms/step - loss: 572.9810 - sparse_categorical_accuracy: 0.1960 Accuracy on target test set: 19.11% With more training, this score improves. When this same network is trained with standard classification objective, it yields an accuracy of 7.20% which is significantly lower than what we got with AdaMatch. You can check out this notebook to learn more about the hyperparameters and other experimental details. # Utility function for preprocessing the source test set. def prepare_test_ds_source(image, label): image = tf.image.resize_with_pad(image, RESIZE_TO, RESIZE_TO) image = tf.tile(image, [1, 1, 3]) return image, label source_test_ds = tf.data.Dataset.from_tensor_slices((mnist_x_test, mnist_y_test)) source_test_ds = ( source_test_ds.map(prepare_test_ds_source, num_parallel_calls=AUTO) .batch(TARGET_BATCH_SIZE) .prefetch(AUTO) ) # Evaluation on the source test set. _, accuracy = adamatch_trained_model.evaluate(source_test_ds) print(f\"Accuracy on source test set: {accuracy * 100:.2f}%\") 53/53 [==============================] - 1s 10ms/step - loss: 572.9810 - sparse_categorical_accuracy: 0.6532 Accuracy on source test set: 65.32% You can reproduce the results by using these model weights. A simple convnet that achieves ~99% test accuracy on MNIST. Setup import numpy as np from tensorflow import keras from tensorflow.keras import layers Prepare the data # Model / data parameters num_classes = 10 input_shape = (28, 28, 1) # the data, split between train and test sets (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() # Scale images to the [0, 1] range x_train = x_train.astype(\"float32\") / 255 x_test = x_test.astype(\"float32\") / 255 # Make sure images have shape (28, 28, 1) x_train = np.expand_dims(x_train, -1) x_test = np.expand_dims(x_test, -1) print(\"x_train shape:\", x_train.shape) print(x_train.shape[0], \"train samples\") print(x_test.shape[0], \"test samples\") # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) x_train shape: (60000, 28, 28, 1) 60000 train samples 10000 test samples Build the model model = keras.Sequential( [ keras.Input(shape=input_shape), layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Conv2D(64, kernel_size=(3, 3), activation=\"relu\"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Flatten(), layers.Dropout(0.5), layers.Dense(num_classes, activation=\"softmax\"), ] ) model.summary() Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 26, 26, 32) 320 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 13, 13, 32) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 11, 11, 64) 18496 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 5, 5, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 1600) 0 _________________________________________________________________ dropout (Dropout) (None, 1600) 0 _________________________________________________________________ dense (Dense) (None, 10) 16010 ================================================================= Total params: 34,826 Trainable params: 34,826 Non-trainable params: 0 _________________________________________________________________ Train the model batch_size = 128 epochs = 15 model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=["accuracy"]) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1) Epoch 1/15 422/422 [==============================] - 13s 29ms/step - loss: 0.7840 - accuracy: 0.7643 - val_loss: 0.0780 - val_accuracy: 0.9780 Epoch 2/15 422/422 [==============================] - 13s 31ms/step - loss: 0.1199 - accuracy: 0.9639 - val_loss: 0.0559 - val_accuracy: 0.9843 Epoch 3/15 422/422 [==============================] - 14s 33ms/step - loss: 0.0845 - accuracy: 0.9737 - val_loss: 0.0469 - val_accuracy: 0.9877 Epoch 4/15 422/422 [==============================] - 14s 33ms/step - loss: 0.0762 - accuracy: 0.9756 - val_loss: 0.0398 - val_accuracy: 0.9895 Epoch 5/15 422/422 [==============================] - 15s 35ms/step - loss: 0.0621 - accuracy: 0.9812 - val_loss: 0.0378 - val_accuracy: 0.9890 Epoch 6/15 422/422 [==============================] - 17s 40ms/step - loss: 0.0547 - accuracy: 0.9825 - val_loss: 0.0360 - val_accuracy: 0.9910 Epoch 7/15 422/422 [==============================] - 17s 41ms/step - loss: 0.0497 - accuracy: 0.9840 - val_loss: 0.0311 - val_accuracy: 0.9920 Epoch 8/15 422/422 [==============================] - 16s 39ms/step - loss: 0.0443 - accuracy: 0.9862 - val_loss: 0.0346 - val_accuracy: 0.9910 Epoch 9/15 422/422 [==============================] - 17s 39ms/step - loss: 0.0436 - accuracy: 0.9860 - val_loss: 0.0325 - val_accuracy: 0.9915 Epoch 10/15 422/422 [==============================] - 16s 38ms/step - loss: 0.0407 - accuracy: 0.9865 - val_loss: 0.0301 - val_accuracy: 0.9920 Epoch 11/15 422/422 [==============================] - 16s 37ms/step - loss: 0.0406 - accuracy: 0.9874 - val_loss: 0.0303 - val_accuracy: 0.9920 Epoch 12/15 237/422 [===============>..............] - ETA: 7s - loss: 0.0398 - accuracy: 0.9877 Evaluate the trained model score = model.evaluate(x_test, y_test, verbose=0) print(\"Test loss:\", score[0]) print(\"Test accuracy:\", score[1]) Test loss: 0.023950600996613503 Test accuracy: 0.9922000169754028 Using supervised contrastive learning for image classification. Introduction Supervised Contrastive Learning (Prannay Khosla et al.) is a training methodology that outperforms supervised training with crossentropy on classification tasks. Essentially, training an image classification model with Supervised Contrastive Learning is performed in two phases: Training an encoder to learn to produce vector representations of input images such that representations of images in the same class will be more similar compared to representations of images in different classes. Training a classifier on top of the frozen encoder. Note that this example requires TensorFlow Addons, which you can install using the following command: pip install tensorflow-addons Setup import tensorflow as tf import tensorflow_addons as tfa import numpy as np from tensorflow import keras from tensorflow.keras import layers Prepare the data num_classes = 10 input_shape = (32, 32, 3) # Load the train and test data splits (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() # Display shapes of train and test datasets print(f\"x_train shape: {x_train.shape} - y_train shape: {y_train.shape}\") print(f\"x_test shape: {x_test.shape} - y_test shape: {y_test.shape}\") x_train shape: (50000, 32, 32, 3) - y_train shape: (50000, 1) x_test shape: (10000, 32, 32, 3) - y_test shape: (10000, 1) Using image data augmentation data_augmentation = keras.Sequential( [ layers.Normalization(), layers.RandomFlip(\"horizontal\"), layers.RandomRotation(0.02), layers.RandomWidth(0.2), layers.RandomHeight(0.2), ] ) # Setting the state of the normalization layer. data_augmentation.layers[0].adapt(x_train) Build the encoder model The encoder model takes the image as input and turns it into a 2048-dimensional feature vector. def create_encoder(): resnet = keras.applications.ResNet50V2( include_top=False, weights=None, input_shape=input_shape, pooling=\"avg\" ) inputs = keras.Input(shape=input_shape) augmented = data_augmentation(inputs) outputs = resnet(augmented) model = keras.Model(inputs=inputs, outputs=outputs, name=\"cifar10-encoder\") return model encoder = create_encoder() encoder.summary() learning_rate = 0.001 batch_size = 265 hidden_units = 512 projection_units = 128 num_epochs = 50 dropout_rate = 0.5 temperature = 0.05 Model: \"cifar10-encoder\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) [(None, 32, 32, 3)] 0 _________________________________________________________________ sequential (Sequential) (None, None, None, 3) 7 _________________________________________________________________ resnet50v2 (Functional) (None, 2048) 23564800 ================================================================= Total params: 23,564,807 Trainable params: 23,519,360 Non-trainable params: 45,447 _________________________________________________________________ Build the classification model The classification model adds a fully-connected layer on top of the encoder, plus a softmax layer with the target classes. def create_classifier(encoder, trainable=True): for layer in encoder.layers: layer.trainable = trainable inputs = keras.Input(shape=input_shape) features = encoder(inputs) features = layers.Dropout(dropout_rate)(features) features = layers.Dense(hidden_units, activation=\"relu\")(features) features = layers.Dropout(dropout_rate)(features) outputs = layers.Dense(num_classes, activation=\"softmax\")(features) model = keras.Model(inputs=inputs, outputs=outputs, name=\"cifar10-classifier\") model.compile( optimizer=keras.optimizers.Adam(learning_rate), loss=keras.losses.SparseCategoricalCrossentropy(), metrics=[keras.metrics.SparseCategoricalAccuracy()], ) return model Experiment 1: Train the baseline classification model In this experiment, a baseline classifier is trained as usual, i.e., the encoder and the classifier parts are trained together as a single model to minimize the crossentropy loss. encoder = create_encoder() classifier = create_classifier(encoder) classifier.summary() history = classifier.fit(x=x_train, y=y_train, batch_size=batch_size, epochs=num_epochs) accuracy = classifier.evaluate(x_test, y_test)[1] print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") Model: \"cifar10-classifier\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_5 (InputLayer) [(None, 32, 32, 3)] 0 _________________________________________________________________ cifar10-encoder (Functional) (None, 2048) 23564807 _________________________________________________________________ dropout (Dropout) (None, 2048) 0 _________________________________________________________________ dense (Dense) (None, 512) 1049088 _________________________________________________________________ dropout_1 (Dropout) (None, 512) 0 _________________________________________________________________ dense_1 (Dense) (None, 10) 5130 ================================================================= Total params: 24,619,025 Trainable params: 24,573,578 Non-trainable params: 45,447 _________________________________________________________________ Epoch 1/50 189/189 [==============================] - 15s 77ms/step - loss: 1.9369 - sparse_categorical_accuracy: 0.2874 Epoch 2/50 189/189 [==============================] - 11s 57ms/step - loss: 1.5133 - sparse_categorical_accuracy: 0.4505 Epoch 3/50 189/189 [==============================] - 11s 57ms/step - loss: 1.3468 - sparse_categorical_accuracy: 0.5204 Epoch 4/50 189/189 [==============================] - 11s 60ms/step - loss: 1.2159 - sparse_categorical_accuracy: 0.5733 Epoch 5/50 189/189 [==============================] - 11s 56ms/step - loss: 1.1516 - sparse_categorical_accuracy: 0.6032 Epoch 6/50 189/189 [==============================] - 11s 58ms/step - loss: 1.0769 - sparse_categorical_accuracy: 0.6254 Epoch 7/50 189/189 [==============================] - 11s 58ms/step - loss: 0.9964 - sparse_categorical_accuracy: 0.6547 Epoch 8/50 189/189 [==============================] - 10s 55ms/step - loss: 0.9563 - sparse_categorical_accuracy: 0.6703 Epoch 9/50 189/189 [==============================] - 10s 55ms/step - loss: 0.8952 - sparse_categorical_accuracy: 0.6925 Epoch 10/50 189/189 [==============================] - 11s 56ms/step - loss: 0.8986 - sparse_categorical_accuracy: 0.6922 Epoch 11/50 189/189 [==============================] - 10s 55ms/step - loss: 0.8381 - sparse_categorical_accuracy: 0.7145 Epoch 12/50 189/189 [==============================] - 10s 55ms/step - loss: 0.8513 - sparse_categorical_accuracy: 0.7086 Epoch 13/50 189/189 [==============================] - 11s 56ms/step - loss: 0.7557 - sparse_categorical_accuracy: 0.7448 Epoch 14/50 189/189 [==============================] - 11s 56ms/step - loss: 0.7168 - sparse_categorical_accuracy: 0.7548 Epoch 15/50 189/189 [==============================] - 10s 55ms/step - loss: 0.6772 - sparse_categorical_accuracy: 0.7690 Epoch 16/50 189/189 [==============================] - 11s 56ms/step - loss: 0.7587 - sparse_categorical_accuracy: 0.7416 Epoch 17/50 189/189 [==============================] - 10s 55ms/step - loss: 0.6873 - sparse_categorical_accuracy: 0.7665 Epoch 18/50 189/189 [==============================] - 11s 56ms/step - loss: 0.6418 - sparse_categorical_accuracy: 0.7804 Epoch 19/50 189/189 [==============================] - 11s 56ms/step - loss: 0.6086 - sparse_categorical_accuracy: 0.7927 Epoch 20/50 189/189 [==============================] - 10s 55ms/step - loss: 0.5903 - sparse_categorical_accuracy: 0.7978 Epoch 21/50 189/189 [==============================] - 11s 56ms/step - loss: 0.5636 - sparse_categorical_accuracy: 0.8083 Epoch 22/50 189/189 [==============================] - 11s 56ms/step - loss: 0.5527 - sparse_categorical_accuracy: 0.8123 Epoch 23/50 189/189 [==============================] - 11s 56ms/step - loss: 0.5308 - sparse_categorical_accuracy: 0.8191 Epoch 24/50 189/189 [==============================] - 10s 55ms/step - loss: 0.5282 - sparse_categorical_accuracy: 0.8223 Epoch 25/50 189/189 [==============================] - 10s 55ms/step - loss: 0.5090 - sparse_categorical_accuracy: 0.8263 Epoch 26/50 189/189 [==============================] - 10s 55ms/step - loss: 0.5497 - sparse_categorical_accuracy: 0.8181 Epoch 27/50 189/189 [==============================] - 10s 55ms/step - loss: 0.4950 - sparse_categorical_accuracy: 0.8332 Epoch 28/50 189/189 [==============================] - 11s 56ms/step - loss: 0.4727 - sparse_categorical_accuracy: 0.8391 Epoch 29/50 167/189 [=========================>....] - ETA: 1s - loss: 0.4594 - sparse_categorical_accuracy: 0.8444 Experiment 2: Use supervised contrastive learning In this experiment, the model is trained in two phases. In the first phase, the encoder is pretrained to optimize the supervised contrastive loss, described in Prannay Khosla et al.. In the second phase, the classifier is trained using the trained encoder with its weights freezed; only the weights of fully-connected layers with the softmax are optimized. 1. Supervised contrastive learning loss function class SupervisedContrastiveLoss(keras.losses.Loss): def __init__(self, temperature=1, name=None): super(SupervisedContrastiveLoss, self).__init__(name=name) self.temperature = temperature def __call__(self, labels, feature_vectors, sample_weight=None): # Normalize feature vectors feature_vectors_normalized = tf.math.l2_normalize(feature_vectors, axis=1) # Compute logits logits = tf.divide( tf.matmul( feature_vectors_normalized, tf.transpose(feature_vectors_normalized) ), self.temperature, ) return tfa.losses.npairs_loss(tf.squeeze(labels), logits) def add_projection_head(encoder): inputs = keras.Input(shape=input_shape) features = encoder(inputs) outputs = layers.Dense(projection_units, activation=\"relu\")(features) model = keras.Model( inputs=inputs, outputs=outputs, name=\"cifar-encoder_with_projection-head\" ) return model 2. Pretrain the encoder encoder = create_encoder() encoder_with_projection_head = add_projection_head(encoder) encoder_with_projection_head.compile( optimizer=keras.optimizers.Adam(learning_rate), loss=SupervisedContrastiveLoss(temperature), ) encoder_with_projection_head.summary() history = encoder_with_projection_head.fit( x=x_train, y=y_train, batch_size=batch_size, epochs=num_epochs ) Model: \"cifar-encoder_with_projection-head\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_8 (InputLayer) [(None, 32, 32, 3)] 0 _________________________________________________________________ cifar10-encoder (Functional) (None, 2048) 23564807 _________________________________________________________________ dense_2 (Dense) (None, 128) 262272 ================================================================= Total params: 23,827,079 Trainable params: 23,781,632 Non-trainable params: 45,447 _________________________________________________________________ Epoch 1/50 189/189 [==============================] - 11s 56ms/step - loss: 5.3730 Epoch 2/50 189/189 [==============================] - 11s 56ms/step - loss: 5.1583 Epoch 3/50 189/189 [==============================] - 10s 55ms/step - loss: 5.0368 Epoch 4/50 189/189 [==============================] - 11s 56ms/step - loss: 4.9349 Epoch 5/50 189/189 [==============================] - 10s 55ms/step - loss: 4.8262 Epoch 6/50 189/189 [==============================] - 11s 56ms/step - loss: 4.7470 Epoch 7/50 189/189 [==============================] - 11s 56ms/step - loss: 4.6835 Epoch 8/50 189/189 [==============================] - 11s 56ms/step - loss: 4.6120 Epoch 9/50 189/189 [==============================] - 11s 56ms/step - loss: 4.5608 Epoch 10/50 189/189 [==============================] - 10s 55ms/step - loss: 4.5075 Epoch 11/50 189/189 [==============================] - 11s 56ms/step - loss: 4.4674 Epoch 12/50 189/189 [==============================] - 10s 56ms/step - loss: 4.4362 Epoch 13/50 189/189 [==============================] - 11s 56ms/step - loss: 4.3899 Epoch 14/50 189/189 [==============================] - 10s 55ms/step - loss: 4.3664 Epoch 15/50 189/189 [==============================] - 11s 56ms/step - loss: 4.3188 Epoch 16/50 189/189 [==============================] - 10s 56ms/step - loss: 4.3030 Epoch 17/50 189/189 [==============================] - 11s 57ms/step - loss: 4.2725 Epoch 18/50 189/189 [==============================] - 10s 55ms/step - loss: 4.2523 Epoch 19/50 189/189 [==============================] - 11s 56ms/step - loss: 4.2100 Epoch 20/50 189/189 [==============================] - 10s 55ms/step - loss: 4.2033 Epoch 21/50 189/189 [==============================] - 11s 56ms/step - loss: 4.1741 Epoch 22/50 189/189 [==============================] - 11s 56ms/step - loss: 4.1443 Epoch 23/50 189/189 [==============================] - 11s 56ms/step - loss: 4.1350 Epoch 24/50 189/189 [==============================] - 11s 57ms/step - loss: 4.1192 Epoch 25/50 189/189 [==============================] - 11s 56ms/step - loss: 4.1002 Epoch 26/50 189/189 [==============================] - 11s 57ms/step - loss: 4.0797 Epoch 27/50 189/189 [==============================] - 11s 56ms/step - loss: 4.0547 Epoch 28/50 189/189 [==============================] - 11s 56ms/step - loss: 4.0336 Epoch 29/50 189/189 [==============================] - 11s 56ms/step - loss: 4.0299 Epoch 30/50 189/189 [==============================] - 11s 56ms/step - loss: 4.0031 Epoch 31/50 189/189 [==============================] - 11s 56ms/step - loss: 3.9979 Epoch 32/50 189/189 [==============================] - 11s 56ms/step - loss: 3.9777 Epoch 33/50 189/189 [==============================] - 10s 55ms/step - loss: 3.9800 Epoch 34/50 189/189 [==============================] - 11s 56ms/step - loss: 3.9538 Epoch 35/50 189/189 [==============================] - 11s 56ms/step - loss: 3.9298 Epoch 36/50 189/189 [==============================] - 11s 57ms/step - loss: 3.9241 Epoch 37/50 189/189 [==============================] - 11s 56ms/step - loss: 3.9102 Epoch 38/50 189/189 [==============================] - 11s 56ms/step - loss: 3.9075 Epoch 39/50 189/189 [==============================] - 11s 56ms/step - loss: 3.8897 Epoch 40/50 189/189 [==============================] - 11s 57ms/step - loss: 3.8871 Epoch 41/50 189/189 [==============================] - 11s 56ms/step - loss: 3.8596 Epoch 42/50 189/189 [==============================] - 10s 56ms/step - loss: 3.8526 Epoch 43/50 189/189 [==============================] - 11s 56ms/step - loss: 3.8417 Epoch 44/50 189/189 [==============================] - 10s 55ms/step - loss: 3.8239 Epoch 45/50 189/189 [==============================] - 11s 56ms/step - loss: 3.8178 Epoch 46/50 189/189 [==============================] - 11s 56ms/step - loss: 3.8065 Epoch 47/50 189/189 [==============================] - 11s 56ms/step - loss: 3.8185 Epoch 48/50 189/189 [==============================] - 11s 56ms/step - loss: 3.8022 Epoch 49/50 189/189 [==============================] - 11s 56ms/step - loss: 3.7815 Epoch 50/50 189/189 [==============================] - 11s 56ms/step - loss: 3.7601 3. Train the classifier with the frozen encoder classifier = create_classifier(encoder, trainable=False) history = classifier.fit(x=x_train, y=y_train, batch_size=batch_size, epochs=num_epochs) accuracy = classifier.evaluate(x_test, y_test)[1] print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") Epoch 1/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3979 - sparse_categorical_accuracy: 0.8869 Epoch 2/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3422 - sparse_categorical_accuracy: 0.8959 Epoch 3/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3251 - sparse_categorical_accuracy: 0.9004 Epoch 4/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3313 - sparse_categorical_accuracy: 0.8963 Epoch 5/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3213 - sparse_categorical_accuracy: 0.9006 Epoch 6/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3221 - sparse_categorical_accuracy: 0.9001 Epoch 7/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3134 - sparse_categorical_accuracy: 0.9001 Epoch 8/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3245 - sparse_categorical_accuracy: 0.8978 Epoch 9/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3144 - sparse_categorical_accuracy: 0.9001 Epoch 10/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3191 - sparse_categorical_accuracy: 0.8984 Epoch 11/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3104 - sparse_categorical_accuracy: 0.9025 Epoch 12/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3261 - sparse_categorical_accuracy: 0.8958 Epoch 13/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3130 - sparse_categorical_accuracy: 0.9001 Epoch 14/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3147 - sparse_categorical_accuracy: 0.9003 Epoch 15/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3113 - sparse_categorical_accuracy: 0.9016 Epoch 16/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3114 - sparse_categorical_accuracy: 0.9008 Epoch 17/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3044 - sparse_categorical_accuracy: 0.9026 Epoch 18/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3142 - sparse_categorical_accuracy: 0.8987 Epoch 19/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3139 - sparse_categorical_accuracy: 0.9018 Epoch 20/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3199 - sparse_categorical_accuracy: 0.8987 Epoch 21/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3125 - sparse_categorical_accuracy: 0.8994 Epoch 22/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3291 - sparse_categorical_accuracy: 0.8967 Epoch 23/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3208 - sparse_categorical_accuracy: 0.8963 Epoch 24/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3065 - sparse_categorical_accuracy: 0.9041 Epoch 25/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3099 - sparse_categorical_accuracy: 0.9006 Epoch 26/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3181 - sparse_categorical_accuracy: 0.8986 Epoch 27/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3112 - sparse_categorical_accuracy: 0.9013 Epoch 28/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3136 - sparse_categorical_accuracy: 0.8996 Epoch 29/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3217 - sparse_categorical_accuracy: 0.8969 Epoch 30/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3161 - sparse_categorical_accuracy: 0.8998 Epoch 31/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8999 Epoch 32/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3092 - sparse_categorical_accuracy: 0.9009 Epoch 33/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3246 - sparse_categorical_accuracy: 0.8961 Epoch 34/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3143 - sparse_categorical_accuracy: 0.8995 Epoch 35/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3106 - sparse_categorical_accuracy: 0.9002 Epoch 36/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3210 - sparse_categorical_accuracy: 0.8980 Epoch 37/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3178 - sparse_categorical_accuracy: 0.9009 Epoch 38/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3064 - sparse_categorical_accuracy: 0.9032 Epoch 39/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3196 - sparse_categorical_accuracy: 0.8981 Epoch 40/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3177 - sparse_categorical_accuracy: 0.8988 Epoch 41/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3167 - sparse_categorical_accuracy: 0.8987 Epoch 42/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3110 - sparse_categorical_accuracy: 0.9014 Epoch 43/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3124 - sparse_categorical_accuracy: 0.9002 Epoch 44/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3128 - sparse_categorical_accuracy: 0.8999 Epoch 45/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3131 - sparse_categorical_accuracy: 0.8991 Epoch 46/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3149 - sparse_categorical_accuracy: 0.8992 Epoch 47/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3082 - sparse_categorical_accuracy: 0.9021 Epoch 48/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3223 - sparse_categorical_accuracy: 0.8959 Epoch 49/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3195 - sparse_categorical_accuracy: 0.8981 Epoch 50/50 189/189 [==============================] - 3s 16ms/step - loss: 0.3240 - sparse_categorical_accuracy: 0.8962 313/313 [==============================] - 2s 7ms/step - loss: 0.7332 - sparse_categorical_accuracy: 0.8162 Test accuracy: 81.62% We get to an improved test accuracy. Conclusion As shown in the experiments, using the supervised contrastive learning technique outperformed the conventional technique in terms of the test accuracy. Note that the same training budget (i.e., number of epochs) was given to each technique. Supervised contrastive learning pays off when the encoder involves a complex architecture, like ResNet, and multi-class problems with many labels. In addition, large batch sizes and multi-layer projection heads improve its effectiveness. See the Supervised Contrastive Learning paper for more details. Training a video classifier with transfer learning and a recurrent model on the UCF101 dataset. This example demonstrates video classification, an important use-case with applications in recommendations, security, and so on. We will be using the UCF101 dataset to build our video classifier. The dataset consists of videos categorized into different actions, like cricket shot, punching, biking, etc. This dataset is commonly used to build action recognizers, which are an application of video classification. A video consists of an ordered sequence of frames. Each frame contains spatial information, and the sequence of those frames contains temporal information. To model both of these aspects, we use a hybrid architecture that consists of convolutions (for spatial processing) as well as recurrent layers (for temporal processing). Specifically, we'll use a Convolutional Neural Network (CNN) and a Recurrent Neural Network (RNN) consisting of GRU layers. This kind of hybrid architecture is popularly known as a CNN-RNN. This example requires TensorFlow 2.5 or higher, as well as TensorFlow Docs, which can be installed using the following command: !pip install -q git+https://github.com/tensorflow/docs Data collection In order to keep the runtime of this example relatively short, we will be using a subsampled version of the original UCF101 dataset. You can refer to this notebook to know how the subsampling was done. !wget -q https://git.io/JGc31 -O ucf101_top5.tar.gz !tar xf ucf101_top5.tar.gz Setup from tensorflow_docs.vis import embed from tensorflow import keras from imutils import paths import matplotlib.pyplot as plt import tensorflow as tf import pandas as pd import numpy as np import imageio import cv2 import os 2021-09-13 14:08:15.945527: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory 2021-09-13 14:08:15.945551: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine. Define hyperparameters IMG_SIZE = 224 BATCH_SIZE = 64 EPOCHS = 10 MAX_SEQ_LENGTH = 20 NUM_FEATURES = 2048 Data preparation train_df = pd.read_csv(\"train.csv\") test_df = pd.read_csv(\"test.csv\") print(f\"Total videos for training: {len(train_df)}\") print(f\"Total videos for testing: {len(test_df)}\") train_df.sample(10) Total videos for training: 594 Total videos for testing: 224 video_name tag 149 v_PlayingCello_g12_c05.avi PlayingCello 317 v_Punch_g19_c05.avi Punch 438 v_ShavingBeard_g20_c03.avi ShavingBeard 559 v_TennisSwing_g20_c02.avi TennisSwing 368 v_ShavingBeard_g09_c03.avi ShavingBeard 241 v_Punch_g08_c04.avi Punch 398 v_ShavingBeard_g14_c03.avi ShavingBeard 111 v_CricketShot_g25_c01.avi CricketShot 119 v_PlayingCello_g08_c02.avi PlayingCello 249 v_Punch_g09_c05.avi Punch One of the many challenges of training video classifiers is figuring out a way to feed the videos to a network. This blog post discusses five such methods. Since a video is an ordered sequence of frames, we could just extract the frames and put them in a 3D tensor. But the number of frames may differ from video to video which would prevent us from stacking them into batches (unless we use padding). As an alternative, we can save video frames at a fixed interval until a maximum frame count is reached. In this example we will do the following: Capture the frames of a video. Extract frames from the videos until a maximum frame count is reached. In the case, where a video's frame count is lesser than the maximum frame count we will pad the video with zeros. Note that this workflow is identical to problems involving texts sequences. Videos of the UCF101 dataset is known to not contain extreme variations in objects and actions across frames. Because of this, it may be okay to only consider a few frames for the learning task. But this approach may not generalize well to other video classification problems. We will be using OpenCV's VideoCapture() method to read frames from videos. # The following two methods are taken from this tutorial: # https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub def crop_center_square(frame): y, x = frame.shape[0:2] min_dim = min(y, x) start_x = (x // 2) - (min_dim // 2) start_y = (y // 2) - (min_dim // 2) return frame[start_y : start_y + min_dim, start_x : start_x + min_dim] def load_video(path, max_frames=0, resize=(IMG_SIZE, IMG_SIZE)): cap = cv2.VideoCapture(path) frames = [] try: while True: ret, frame = cap.read() if not ret: break frame = crop_center_square(frame) frame = cv2.resize(frame, resize) frame = frame[:, :, [2, 1, 0]] frames.append(frame) if len(frames) == max_frames: break finally: cap.release() return np.array(frames) We can use a pre-trained network to extract meaningful features from the extracted frames. The Keras Applications module provides a number of state-of-the-art models pre-trained on the ImageNet-1k dataset. We will be using the InceptionV3 model for this purpose. def build_feature_extractor(): feature_extractor = keras.applications.InceptionV3( weights=\"imagenet\", include_top=False, pooling=\"avg\", input_shape=(IMG_SIZE, IMG_SIZE, 3), ) preprocess_input = keras.applications.inception_v3.preprocess_input inputs = keras.Input((IMG_SIZE, IMG_SIZE, 3)) preprocessed = preprocess_input(inputs) outputs = feature_extractor(preprocessed) return keras.Model(inputs, outputs, name=\"feature_extractor\") feature_extractor = build_feature_extractor() 2021-09-13 14:08:17.043898: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-13 14:08:17.044381: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory 2021-09-13 14:08:17.044436: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory 2021-09-13 14:08:17.044470: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory 2021-09-13 14:08:17.055998: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory 2021-09-13 14:08:17.056056: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory 2021-09-13 14:08:17.056646: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1835] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform. Skipping registering GPU devices... 2021-09-13 14:08:17.056971: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. The labels of the videos are strings. Neural networks do not understand string values, so they must be converted to some numerical form before they are fed to the model. Here we will use the StringLookup layer encode the class labels as integers. label_processor = keras.layers.StringLookup( num_oov_indices=0, vocabulary=np.unique(train_df[\"tag\"]) ) print(label_processor.get_vocabulary()) ['CricketShot', 'PlayingCello', 'Punch', 'ShavingBeard', 'TennisSwing'] Finally, we can put all the pieces together to create our data processing utility. def prepare_all_videos(df, root_dir): num_samples = len(df) video_paths = df[\"video_name\"].values.tolist() labels = df[\"tag\"].values labels = label_processor(labels[..., None]).numpy() # `frame_masks` and `frame_features` are what we will feed to our sequence model. # `frame_masks` will contain a bunch of booleans denoting if a timestep is # masked with padding or not. frame_masks = np.zeros(shape=(num_samples, MAX_SEQ_LENGTH), dtype=\"bool\") frame_features = np.zeros( shape=(num_samples, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\" ) # For each video. for idx, path in enumerate(video_paths): # Gather all its frames and add a batch dimension. frames = load_video(os.path.join(root_dir, path)) frames = frames[None, ...] # Initialize placeholders to store the masks and features of the current video. temp_frame_mask = np.zeros(shape=(1, MAX_SEQ_LENGTH,), dtype=\"bool\") temp_frame_features = np.zeros( shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\" ) # Extract features from the frames of the current video. for i, batch in enumerate(frames): video_length = batch.shape[0] length = min(MAX_SEQ_LENGTH, video_length) for j in range(length): temp_frame_features[i, j, :] = feature_extractor.predict( batch[None, j, :] ) temp_frame_mask[i, :length] = 1 # 1 = not masked, 0 = masked frame_features[idx,] = temp_frame_features.squeeze() frame_masks[idx,] = temp_frame_mask.squeeze() return (frame_features, frame_masks), labels train_data, train_labels = prepare_all_videos(train_df, \"train\") test_data, test_labels = prepare_all_videos(test_df, \"test\") print(f\"Frame features in train set: {train_data[0].shape}\") print(f\"Frame masks in train set: {train_data[1].shape}\") 2021-09-13 14:08:18.486751: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2) Frame features in train set: (594, 20, 2048) Frame masks in train set: (594, 20) The above code block will take ~20 minutes to execute depending on the machine it's being executed. The sequence model Now, we can feed this data to a sequence model consisting of recurrent layers like GRU. # Utility for our sequence model. def get_sequence_model(): class_vocab = label_processor.get_vocabulary() frame_features_input = keras.Input((MAX_SEQ_LENGTH, NUM_FEATURES)) mask_input = keras.Input((MAX_SEQ_LENGTH,), dtype=\"bool\") # Refer to the following tutorial to understand the significance of using `mask`: # https://keras.io/api/layers/recurrent_layers/gru/ x = keras.layers.GRU(16, return_sequences=True)( frame_features_input, mask=mask_input ) x = keras.layers.GRU(8)(x) x = keras.layers.Dropout(0.4)(x) x = keras.layers.Dense(8, activation=\"relu\")(x) output = keras.layers.Dense(len(class_vocab), activation=\"softmax\")(x) rnn_model = keras.Model([frame_features_input, mask_input], output) rnn_model.compile( loss=\"sparse_categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"] ) return rnn_model # Utility for running experiments. def run_experiment(): filepath = \"/tmp/video_classifier\" checkpoint = keras.callbacks.ModelCheckpoint( filepath, save_weights_only=True, save_best_only=True, verbose=1 ) seq_model = get_sequence_model() history = seq_model.fit( [train_data[0], train_data[1]], train_labels, validation_split=0.3, epochs=EPOCHS, callbacks=[checkpoint], ) seq_model.load_weights(filepath) _, accuracy = seq_model.evaluate([test_data[0], test_data[1]], test_labels) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") return history, seq_model _, sequence_model = run_experiment() Epoch 1/10 13/13 [==============================] - 4s 101ms/step - loss: 1.5259 - accuracy: 0.3157 - val_loss: 1.4732 - val_accuracy: 0.3408 Epoch 00001: val_loss improved from inf to 1.47325, saving model to /tmp/video_classifier Epoch 2/10 13/13 [==============================] - 0s 21ms/step - loss: 1.3087 - accuracy: 0.5880 - val_loss: 1.4751 - val_accuracy: 0.3408 Epoch 00002: val_loss did not improve from 1.47325 Epoch 3/10 13/13 [==============================] - 0s 20ms/step - loss: 1.1532 - accuracy: 0.6795 - val_loss: 1.5020 - val_accuracy: 0.3408 Epoch 00003: val_loss did not improve from 1.47325 Epoch 4/10 13/13 [==============================] - 0s 20ms/step - loss: 1.0586 - accuracy: 0.7325 - val_loss: 1.5205 - val_accuracy: 0.3464 Epoch 00004: val_loss did not improve from 1.47325 Epoch 5/10 13/13 [==============================] - 0s 21ms/step - loss: 0.9556 - accuracy: 0.7422 - val_loss: 1.5748 - val_accuracy: 0.3464 Epoch 00005: val_loss did not improve from 1.47325 Epoch 6/10 13/13 [==============================] - 0s 21ms/step - loss: 0.8988 - accuracy: 0.7783 - val_loss: 1.6144 - val_accuracy: 0.3464 Epoch 00006: val_loss did not improve from 1.47325 Epoch 7/10 13/13 [==============================] - 0s 21ms/step - loss: 0.8242 - accuracy: 0.8072 - val_loss: 1.7030 - val_accuracy: 0.3408 Epoch 00007: val_loss did not improve from 1.47325 Epoch 8/10 13/13 [==============================] - 0s 20ms/step - loss: 0.7479 - accuracy: 0.8434 - val_loss: 1.7466 - val_accuracy: 0.3464 Epoch 00008: val_loss did not improve from 1.47325 Epoch 9/10 13/13 [==============================] - 0s 20ms/step - loss: 0.6740 - accuracy: 0.8627 - val_loss: 1.8800 - val_accuracy: 0.3464 Epoch 00009: val_loss did not improve from 1.47325 Epoch 10/10 13/13 [==============================] - 0s 20ms/step - loss: 0.6519 - accuracy: 0.8265 - val_loss: 1.9150 - val_accuracy: 0.3464 Epoch 00010: val_loss did not improve from 1.47325 7/7 [==============================] - 1s 5ms/step - loss: 1.3806 - accuracy: 0.6875 Test accuracy: 68.75% Note: To keep the runtime of this example relatively short, we just used a few training examples. This number of training examples is low with respect to the sequence model being used that has 99,909 trainable parameters. You are encouraged to sample more data from the UCF101 dataset using the notebook mentioned above and train the same model. Inference def prepare_single_video(frames): frames = frames[None, ...] frame_mask = np.zeros(shape=(1, MAX_SEQ_LENGTH,), dtype=\"bool\") frame_features = np.zeros(shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\") for i, batch in enumerate(frames): video_length = batch.shape[0] length = min(MAX_SEQ_LENGTH, video_length) for j in range(length): frame_features[i, j, :] = feature_extractor.predict(batch[None, j, :]) frame_mask[i, :length] = 1 # 1 = not masked, 0 = masked return frame_features, frame_mask def sequence_prediction(path): class_vocab = label_processor.get_vocabulary() frames = load_video(os.path.join(\"test\", path)) frame_features, frame_mask = prepare_single_video(frames) probabilities = sequence_model.predict([frame_features, frame_mask])[0] for i in np.argsort(probabilities)[::-1]: print(f\" {class_vocab[i]}: {probabilities[i] * 100:5.2f}%\") return frames # This utility is for visualization. # Referenced from: # https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub def to_gif(images): converted_images = images.astype(np.uint8) imageio.mimsave(\"animation.gif\", converted_images, fps=10) return embed.embed_file(\"animation.gif\") test_video = np.random.choice(test_df[\"video_name\"].values.tolist()) print(f\"Test video path: {test_video}\") test_frames = sequence_prediction(test_video) to_gif(test_frames[:MAX_SEQ_LENGTH]) Test video path: v_PlayingCello_g05_c03.avi PlayingCello: 25.61% CricketShot: 24.82% ShavingBeard: 19.38% TennisSwing: 17.43% Punch: 12.77% Next steps In this example, we made use of transfer learning for extracting meaningful features from video frames. You could also fine-tune the pre-trained network to notice how that affects the end results. For speed-accuracy trade-offs, you can try out other models present inside tf.keras.applications. Try different combinations of MAX_SEQ_LENGTH to observe how that affects the performance. Train on a higher number of classes and see if you are able to get good performance. Following this tutorial, try a pre-trained action recognition model from DeepMind. Rolling-averaging can be useful technique for video classification and it can be combined with a standard image classification model to infer on videos. This tutorial will help understand how to use rolling-averaging with an image classifier. When there are variations in between the frames of a video not all the frames might be equally important to decide its category. In those situations, putting a self-attention layer in the sequence model will likely yield better results. Following this book chapter, you can implement Transformers-based models for processing videos. Training a video classifier with hybrid transformers. This example is a follow-up to the Video Classification with a CNN-RNN Architecture example. This time, we will be using a Transformer-based model (Vaswani et al.) to classify videos. You can follow this book chapter in case you need an introduction to Transformers (with code). After reading this example, you will know how to develop hybrid Transformer-based models for video classification that operate on CNN feature maps. This example requires TensorFlow 2.5 or higher, as well as TensorFlow Docs, which can be installed using the following command: !pip install -q git+https://github.com/tensorflow/docs  WARNING: Built wheel for tensorflow-docs is invalid: Metadata 1.2 mandates PEP 440 version, but '0.0.0543363dfdc669b09def1e06abdd34b76337fba4e-' is not  DEPRECATION: tensorflow-docs was installed using the legacy 'setup.py install' method, because a wheel could not be built for it. A possible replacement is to fix the wheel build issue reported above. You can find discussion regarding this at https://github.com/pypa/pip/issues/8368. Data collection As done in the predecessor to this example, we will be using a subsampled version of the UCF101 dataset, a well-known benchmark dataset. In case you want to operate on a larger subsample or even the entire dataset, please refer to this notebook. !wget -q https://git.io/JGc31 -O ucf101_top5.tar.gz !tar xf ucf101_top5.tar.gz Setup from tensorflow_docs.vis import embed from tensorflow.keras import layers from tensorflow import keras import matplotlib.pyplot as plt import tensorflow as tf import pandas as pd import numpy as np import imageio import cv2 import os 2021-09-14 13:26:26.593418: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory 2021-09-14 13:26:26.593444: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine. Define hyperparameters MAX_SEQ_LENGTH = 20 NUM_FEATURES = 1024 IMG_SIZE = 128 EPOCHS = 5 Data preparation We will mostly be following the same data preparation steps in this example, except for the following changes: We reduce the image size to 128x128 instead of 224x224 to speed up computation. Instead of using a pre-trained InceptionV3 network, we use a pre-trained DenseNet121 for feature extraction. We directly pad shorter videos to length MAX_SEQ_LENGTH. First, let's load up the DataFrames. train_df = pd.read_csv(\"train.csv\") test_df = pd.read_csv(\"test.csv\") print(f\"Total videos for training: {len(train_df)}\") print(f\"Total videos for testing: {len(test_df)}\") center_crop_layer = layers.CenterCrop(IMG_SIZE, IMG_SIZE) def crop_center(frame): cropped = center_crop_layer(frame[None, ...]) cropped = cropped.numpy().squeeze() return cropped # Following method is modified from this tutorial: # https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub def load_video(path, max_frames=0): cap = cv2.VideoCapture(path) frames = [] try: while True: ret, frame = cap.read() if not ret: break frame = crop_center(frame) frame = frame[:, :, [2, 1, 0]] frames.append(frame) if len(frames) == max_frames: break finally: cap.release() return np.array(frames) def build_feature_extractor(): feature_extractor = keras.applications.DenseNet121( weights=\"imagenet\", include_top=False, pooling=\"avg\", input_shape=(IMG_SIZE, IMG_SIZE, 3), ) preprocess_input = keras.applications.densenet.preprocess_input inputs = keras.Input((IMG_SIZE, IMG_SIZE, 3)) preprocessed = preprocess_input(inputs) outputs = feature_extractor(preprocessed) return keras.Model(inputs, outputs, name=\"feature_extractor\") feature_extractor = build_feature_extractor() # Label preprocessing with StringLookup. label_processor = keras.layers.StringLookup( num_oov_indices=0, vocabulary=np.unique(train_df[\"tag\"]), mask_token=None ) print(label_processor.get_vocabulary()) def prepare_all_videos(df, root_dir): num_samples = len(df) video_paths = df[\"video_name\"].values.tolist() labels = df[\"tag\"].values labels = label_processor(labels[..., None]).numpy() # `frame_features` are what we will feed to our sequence model. frame_features = np.zeros( shape=(num_samples, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\" ) # For each video. for idx, path in enumerate(video_paths): # Gather all its frames and add a batch dimension. frames = load_video(os.path.join(root_dir, path)) # Pad shorter videos. if len(frames) < MAX_SEQ_LENGTH: diff = MAX_SEQ_LENGTH - len(frames) padding = np.zeros((diff, IMG_SIZE, IMG_SIZE, 3)) frames = np.concatenate(frames, padding) frames = frames[None, ...] # Initialize placeholder to store the features of the current video. temp_frame_features = np.zeros( shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\" ) # Extract features from the frames of the current video. for i, batch in enumerate(frames): video_length = batch.shape[0] length = min(MAX_SEQ_LENGTH, video_length) for j in range(length): if np.mean(batch[j, :]) > 0.0: temp_frame_features[i, j, :] = feature_extractor.predict( batch[None, j, :] ) else: temp_frame_features[i, j, :] = 0.0 frame_features[idx,] = temp_frame_features.squeeze() return frame_features, labels Total videos for training: 594 Total videos for testing: 224 2021-09-14 13:26:28.169035: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero 2021-09-14 13:26:28.169629: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory 2021-09-14 13:26:28.169696: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory 2021-09-14 13:26:28.169746: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory 2021-09-14 13:26:28.179403: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory 2021-09-14 13:26:28.179462: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory 2021-09-14 13:26:28.180051: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1835] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform. Skipping registering GPU devices... 2021-09-14 13:26:28.180325: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags. Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/densenet/densenet121_weights_tf_dim_ordering_tf_kernels_notop.h5 29089792/29084464 [==============================] - 1s 0us/step 29097984/29084464 [==============================] - 1s 0us/step ['CricketShot', 'PlayingCello', 'Punch', 'ShavingBeard', 'TennisSwing'] Calling prepare_all_videos() on train_df and test_df takes ~20 minutes to complete. For this reason, to save time, here we download already preprocessed NumPy arrays: !wget -q https://git.io/JZmf4 -O top5_data_prepared.tar.gz !tar xf top5_data_prepared.tar.gz train_data, train_labels = np.load(\"train_data.npy\"), np.load(\"train_labels.npy\") test_data, test_labels = np.load(\"test_data.npy\"), np.load(\"test_labels.npy\") print(f\"Frame features in train set: {train_data.shape}\") Frame features in train set: (594, 20, 1024) Building the Transformer-based model We will be building on top of the code shared in this book chapter of Deep Learning with Python (Second ed.) by François Chollet. First, self-attention layers that form the basic blocks of a Transformer are order-agnostic. Since videos are ordered sequences of frames, we need our Transformer model to take into account order information. We do this via positional encoding. We simply embed the positions of the frames present inside videos with an Embedding layer. We then add these positional embeddings to the precomputed CNN feature maps. class PositionalEmbedding(layers.Layer): def __init__(self, sequence_length, output_dim, **kwargs): super().__init__(**kwargs) self.position_embeddings = layers.Embedding( input_dim=sequence_length, output_dim=output_dim ) self.sequence_length = sequence_length self.output_dim = output_dim def call(self, inputs): # The inputs are of shape: `(batch_size, frames, num_features)` length = tf.shape(inputs)[1] positions = tf.range(start=0, limit=length, delta=1) embedded_positions = self.position_embeddings(positions) return inputs + embedded_positions def compute_mask(self, inputs, mask=None): mask = tf.reduce_any(tf.cast(inputs, \"bool\"), axis=-1) return mask Now, we can create a subclassed layer for the Transformer. class TransformerEncoder(layers.Layer): def __init__(self, embed_dim, dense_dim, num_heads, **kwargs): super().__init__(**kwargs) self.embed_dim = embed_dim self.dense_dim = dense_dim self.num_heads = num_heads self.attention = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim, dropout=0.3 ) self.dense_proj = keras.Sequential( [layers.Dense(dense_dim, activation=tf.nn.gelu), layers.Dense(embed_dim),] ) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() def call(self, inputs, mask=None): if mask is not None: mask = mask[:, tf.newaxis, :] attention_output = self.attention(inputs, inputs, attention_mask=mask) proj_input = self.layernorm_1(inputs + attention_output) proj_output = self.dense_proj(proj_input) return self.layernorm_2(proj_input + proj_output) Utility functions for training def get_compiled_model(): sequence_length = MAX_SEQ_LENGTH embed_dim = NUM_FEATURES dense_dim = 4 num_heads = 1 classes = len(label_processor.get_vocabulary()) inputs = keras.Input(shape=(None, None)) x = PositionalEmbedding( sequence_length, embed_dim, name=\"frame_position_embedding\" )(inputs) x = TransformerEncoder(embed_dim, dense_dim, num_heads, name=\"transformer_layer\")(x) x = layers.GlobalMaxPooling1D()(x) x = layers.Dropout(0.5)(x) outputs = layers.Dense(classes, activation=\"softmax\")(x) model = keras.Model(inputs, outputs) model.compile( optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"] ) return model def run_experiment(): filepath = \"/tmp/video_classifier\" checkpoint = keras.callbacks.ModelCheckpoint( filepath, save_weights_only=True, save_best_only=True, verbose=1 ) model = get_compiled_model() history = model.fit( train_data, train_labels, validation_split=0.15, epochs=EPOCHS, callbacks=[checkpoint], ) model.load_weights(filepath) _, accuracy = model.evaluate(test_data, test_labels) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") return model Model training and inference trained_model = run_experiment() 2021-09-14 13:27:55.649167: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2) Epoch 1/5 16/16 [==============================] - 2s 69ms/step - loss: 1.7206 - accuracy: 0.6548 - val_loss: 1.6100 - val_accuracy: 0.2889 Epoch 00001: val_loss improved from inf to 1.61001, saving model to /tmp/video_classifier Epoch 2/5 16/16 [==============================] - 1s 58ms/step - loss: 0.1306 - accuracy: 0.9524 - val_loss: 1.9321 - val_accuracy: 0.4111 Epoch 00002: val_loss did not improve from 1.61001 Epoch 3/5 16/16 [==============================] - 1s 58ms/step - loss: 0.0704 - accuracy: 0.9742 - val_loss: 0.7381 - val_accuracy: 0.7556 Epoch 00003: val_loss improved from 1.61001 to 0.73814, saving model to /tmp/video_classifier Epoch 4/5 16/16 [==============================] - 1s 56ms/step - loss: 0.0208 - accuracy: 0.9901 - val_loss: 0.8953 - val_accuracy: 0.7778 Epoch 00004: val_loss did not improve from 0.73814 Epoch 5/5 16/16 [==============================] - 1s 56ms/step - loss: 0.0076 - accuracy: 0.9980 - val_loss: 1.5643 - val_accuracy: 0.7111 Epoch 00005: val_loss did not improve from 0.73814 7/7 [==============================] - 0s 20ms/step - loss: 0.5903 - accuracy: 0.8750 Test accuracy: 87.5% Note: This model has ~4.23 Million parameters, which is way more than the sequence model (99918 parameters) we used in the prequel of this example. This kind of Transformer model works best with a larger dataset and a longer pre-training schedule. def prepare_single_video(frames): frame_features = np.zeros(shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\") # Pad shorter videos. if len(frames) < MAX_SEQ_LENGTH: diff = MAX_SEQ_LENGTH - len(frames) padding = np.zeros((diff, IMG_SIZE, IMG_SIZE, 3)) frames = np.concatenate(frames, padding) frames = frames[None, ...] # Extract features from the frames of the current video. for i, batch in enumerate(frames): video_length = batch.shape[0] length = min(MAX_SEQ_LENGTH, video_length) for j in range(length): if np.mean(batch[j, :]) > 0.0: frame_features[i, j, :] = feature_extractor.predict(batch[None, j, :]) else: frame_features[i, j, :] = 0.0 return frame_features def predict_action(path): class_vocab = label_processor.get_vocabulary() frames = load_video(os.path.join(\"test\", path)) frame_features = prepare_single_video(frames) probabilities = trained_model.predict(frame_features)[0] for i in np.argsort(probabilities)[::-1]: print(f\" {class_vocab[i]}: {probabilities[i] * 100:5.2f}%\") return frames # This utility is for visualization. # Referenced from: # https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub def to_gif(images): converted_images = images.astype(np.uint8) imageio.mimsave(\"animation.gif\", converted_images, fps=10) return embed.embed_file(\"animation.gif\") test_video = np.random.choice(test_df[\"video_name\"].values.tolist()) print(f\"Test video path: {test_video}\") test_frames = predict_action(test_video) to_gif(test_frames[:MAX_SEQ_LENGTH]) Test video path: v_TennisSwing_g05_c06.avi TennisSwing: 98.90% CricketShot: 1.10% Punch: 0.00% ShavingBeard: 0.00% PlayingCello: 0.00% The performance of our model is far from optimal, because it was trained on a small dataset. Displaying the visual patterns that convnet filters respond to. Introduction In this example, we look into what sort of visual patterns image classification models learn. We'll be using the ResNet50V2 model, trained on the ImageNet dataset. Our process is simple: we will create input images that maximize the activation of specific filters in a target layer (picked somewhere in the middle of the model: layer conv3_block4_out). Such images represent a visualization of the pattern that the filter responds to. Setup import numpy as np import tensorflow as tf from tensorflow import keras # The dimensions of our input image img_width = 180 img_height = 180 # Our target layer: we will visualize the filters from this layer. # See `model.summary()` for list of layer names, if you want to change this. layer_name = \"conv3_block4_out\" Build a feature extraction model # Build a ResNet50V2 model loaded with pre-trained ImageNet weights model = keras.applications.ResNet50V2(weights=\"imagenet\", include_top=False) # Set up a model that returns the activation values for our target layer layer = model.get_layer(name=layer_name) feature_extractor = keras.Model(inputs=model.inputs, outputs=layer.output) Set up the gradient ascent process The \"loss\" we will maximize is simply the mean of the activation of a specific filter in our target layer. To avoid border effects, we exclude border pixels. def compute_loss(input_image, filter_index): activation = feature_extractor(input_image) # We avoid border artifacts by only involving non-border pixels in the loss. filter_activation = activation[:, 2:-2, 2:-2, filter_index] return tf.reduce_mean(filter_activation) Our gradient ascent function simply computes the gradients of the loss above with regard to the input image, and update the update image so as to move it towards a state that will activate the target filter more strongly. @tf.function def gradient_ascent_step(img, filter_index, learning_rate): with tf.GradientTape() as tape: tape.watch(img) loss = compute_loss(img, filter_index) # Compute gradients. grads = tape.gradient(loss, img) # Normalize gradients. grads = tf.math.l2_normalize(grads) img += learning_rate * grads return loss, img Set up the end-to-end filter visualization loop Our process is as follow: Start from a random image that is close to \"all gray\" (i.e. visually netural) Repeatedly apply the gradient ascent step function defined above Convert the resulting input image back to a displayable form, by normalizing it, center-cropping it, and restricting it to the [0, 255] range. def initialize_image(): # We start from a gray image with some random noise img = tf.random.uniform((1, img_width, img_height, 3)) # ResNet50V2 expects inputs in the range [-1, +1]. # Here we scale our random inputs to [-0.125, +0.125] return (img - 0.5) * 0.25 def visualize_filter(filter_index): # We run gradient ascent for 20 steps iterations = 30 learning_rate = 10.0 img = initialize_image() for iteration in range(iterations): loss, img = gradient_ascent_step(img, filter_index, learning_rate) # Decode the resulting input image img = deprocess_image(img[0].numpy()) return loss, img def deprocess_image(img): # Normalize array: center on 0., ensure variance is 0.15 img -= img.mean() img /= img.std() + 1e-5 img *= 0.15 # Center crop img = img[25:-25, 25:-25, :] # Clip to [0, 1] img += 0.5 img = np.clip(img, 0, 1) # Convert to RGB array img *= 255 img = np.clip(img, 0, 255).astype(\"uint8\") return img Let's try it out with filter 0 in the target layer: from IPython.display import Image, display loss, img = visualize_filter(0) keras.preprocessing.image.save_img(\"0.png\", img) This is what an input that maximizes the response of filter 0 in the target layer would look like: display(Image(\"0.png\")) png Visualize the first 64 filters in the target layer Now, let's make a 8x8 grid of the first 64 filters in the target layer to get of feel for the range of different visual patterns that the model has learned. # Compute image inputs that maximize per-filter activations # for the first 64 filters of our target layer all_imgs = [] for filter_index in range(64): print(\"Processing filter %d\" % (filter_index,)) loss, img = visualize_filter(filter_index) all_imgs.append(img) # Build a black picture with enough space for # our 8 x 8 filters of size 128 x 128, with a 5px margin in between margin = 5 n = 8 cropped_width = img_width - 25 * 2 cropped_height = img_height - 25 * 2 width = n * cropped_width + (n - 1) * margin height = n * cropped_height + (n - 1) * margin stitched_filters = np.zeros((width, height, 3)) # Fill the picture with our saved filters for i in range(n): for j in range(n): img = all_imgs[i * n + j] stitched_filters[ (cropped_width + margin) * i : (cropped_width + margin) * i + cropped_width, (cropped_height + margin) * j : (cropped_height + margin) * j + cropped_height, :, ] = img keras.preprocessing.image.save_img(\"stiched_filters.png\", stitched_filters) from IPython.display import Image, display display(Image(\"stiched_filters.png\")) Processing filter 0 Processing filter 1 Processing filter 2 Processing filter 3 Processing filter 4 Processing filter 5 Processing filter 6 Processing filter 7 Processing filter 8 Processing filter 9 Processing filter 10 Processing filter 11 Processing filter 12 Processing filter 13 Processing filter 14 Processing filter 15 Processing filter 16 Processing filter 17 Processing filter 18 Processing filter 19 Processing filter 20 Processing filter 21 Processing filter 22 Processing filter 23 Processing filter 24 Processing filter 25 Processing filter 26 Processing filter 27 Processing filter 28 Processing filter 29 Processing filter 30 Processing filter 31 Processing filter 32 Processing filter 33 Processing filter 34 Processing filter 35 Processing filter 36 Processing filter 37 Processing filter 38 Processing filter 39 Processing filter 40 Processing filter 41 Processing filter 42 Processing filter 43 Processing filter 44 Processing filter 45 Processing filter 46 Processing filter 47 Processing filter 48 Processing filter 49 Processing filter 50 Processing filter 51 Processing filter 52 Processing filter 53 Processing filter 54 Processing filter 55 Processing filter 56 Processing filter 57 Processing filter 58 Processing filter 59 Processing filter 60 Processing filter 61 Processing filter 62 Processing filter 63 png Image classification models see the world by decomposing their inputs over a \"vector basis\" of texture filters such as these. See also this old blog post for analysis and interpretation. Implementing Zero-Reference Deep Curve Estimation for low-light image enhancement Introduction Zero-Reference Deep Curve Estimation or Zero-DCE formulates low-light image enhancement as the task of estimating an image-specific tonal curve with a deep neural network. In this example, we train a lightweight deep network, DCE-Net, to estimate pixel-wise and high-order tonal curves for dynamic range adjustment of a given image. Zero-DCE takes a low-light image as input and produces high-order tonal curves as its output. These curves are then used for pixel-wise adjustment on the dynamic range of the input to obtain an enhanced image. The curve estimation process is done in such a way that it maintains the range of the enhanced image and preserves the contrast of neighboring pixels. This curve estimation is inspired by curves adjustment used in photo editing software such as Adobe Photoshop where users can adjust points throughout an image’s tonal range. Zero-DCE is appealing because of its relaxed assumptions with regard to reference images: it does not require any input/output image pairs during training. This is achieved through a set of carefully formulated non-reference loss functions, which implicitly measure the enhancement quality and guide the training of the network. References Zero-Reference Deep Curve Estimation for Low-Light Image Enhancement Curves adjustment in Adobe Photoshop Downloading LOLDataset The LoL Dataset has been created for low-light image enhancement. It provides 485 images for training and 15 for testing. Each image pair in the dataset consists of a low-light input image and its corresponding well-exposed reference image. import os import random import numpy as np from glob import glob from PIL import Image, ImageOps import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers !gdown https://drive.google.com/uc?id=1DdGIJ4PZPlF2ikl8mNM9V-PdVxVLbQi6 !unzip -q lol_dataset.zip Downloading... From: https://drive.google.com/uc?id=1DdGIJ4PZPlF2ikl8mNM9V-PdVxVLbQi6 To: /content/keras-io/scripts/tmp_4644685/lol_dataset.zip 347MB [00:03, 93.3MB/s] Creating a TensorFlow Dataset We use 300 low-light images from the LoL Dataset training set for training, and we use the remaining 185 low-light images for validation. We resize the images to size 256 x 256 to be used for both training and validation. Note that in order to train the DCE-Net, we will not require the corresponding enhanced images. IMAGE_SIZE = 256 BATCH_SIZE = 16 MAX_TRAIN_IMAGES = 400 def load_data(image_path): image = tf.io.read_file(image_path) image = tf.image.decode_png(image, channels=3) image = tf.image.resize(images=image, size=[IMAGE_SIZE, IMAGE_SIZE]) image = image / 255.0 return image def data_generator(low_light_images): dataset = tf.data.Dataset.from_tensor_slices((low_light_images)) dataset = dataset.map(load_data, num_parallel_calls=tf.data.AUTOTUNE) dataset = dataset.batch(BATCH_SIZE, drop_remainder=True) return dataset train_low_light_images = sorted(glob(\"./lol_dataset/our485/low/*\"))[:MAX_TRAIN_IMAGES] val_low_light_images = sorted(glob(\"./lol_dataset/our485/low/*\"))[MAX_TRAIN_IMAGES:] test_low_light_images = sorted(glob(\"./lol_dataset/eval15/low/*\")) train_dataset = data_generator(train_low_light_images) val_dataset = data_generator(val_low_light_images) print(\"Train Dataset:\", train_dataset) print(\"Validation Dataset:\", val_dataset) Train Dataset: Validation Dataset: The Zero-DCE Framework The goal of DCE-Net is to estimate a set of best-fitting light-enhancement curves (LE-curves) given an input image. The framework then maps all pixels of the input’s RGB channels by applying the curves iteratively to obtain the final enhanced image. Understanding light-enhancement curves A ligh-enhancement curve is a kind of curve that can map a low-light image to its enhanced version automatically, where the self-adaptive curve parameters are solely dependent on the input image. When designing such a curve, three objectives should be taken into account: Each pixel value of the enhanced image should be in the normalized range [0,1], in order to avoid information loss induced by overflow truncation. It should be monotonous, to preserve the contrast between neighboring pixels. The shape of this curve should be as simple as possible, and the curve should be differentiable to allow backpropagation. The light-enhancement curve is separately applied to three RGB channels instead of solely on the illumination channel. The three-channel adjustment can better preserve the inherent color and reduce the risk of over-saturation. DCE-Net The DCE-Net is a lightweight deep neural network that learns the mapping between an input image and its best-fitting curve parameter maps. The input to the DCE-Net is a low-light image while the outputs are a set of pixel-wise curve parameter maps for corresponding higher-order curves. It is a plain CNN of seven convolutional layers with symmetrical concatenation. Each layer consists of 32 convolutional kernels of size 3×3 and stride 1 followed by the ReLU activation function. The last convolutional layer is followed by the Tanh activation function, which produces 24 parameter maps for 8 iterations, where each iteration requires three curve parameter maps for the three channels. def build_dce_net(): input_img = keras.Input(shape=[None, None, 3]) conv1 = layers.Conv2D( 32, (3, 3), strides=(1, 1), activation=\"relu\", padding=\"same\" )(input_img) conv2 = layers.Conv2D( 32, (3, 3), strides=(1, 1), activation=\"relu\", padding=\"same\" )(conv1) conv3 = layers.Conv2D( 32, (3, 3), strides=(1, 1), activation=\"relu\", padding=\"same\" )(conv2) conv4 = layers.Conv2D( 32, (3, 3), strides=(1, 1), activation=\"relu\", padding=\"same\" )(conv3) int_con1 = layers.Concatenate(axis=-1)([conv4, conv3]) conv5 = layers.Conv2D( 32, (3, 3), strides=(1, 1), activation=\"relu\", padding=\"same\" )(int_con1) int_con2 = layers.Concatenate(axis=-1)([conv5, conv2]) conv6 = layers.Conv2D( 32, (3, 3), strides=(1, 1), activation=\"relu\", padding=\"same\" )(int_con2) int_con3 = layers.Concatenate(axis=-1)([conv6, conv1]) x_r = layers.Conv2D(24, (3, 3), strides=(1, 1), activation=\"tanh\", padding=\"same\")( int_con3 ) return keras.Model(inputs=input_img, outputs=x_r) Loss functions To enable zero-reference learning in DCE-Net, we use a set of differentiable zero-reference losses that allow us to evaluate the quality of enhanced images. Color constancy loss The color constancy loss is used to correct the potential color deviations in the enhanced image. def color_constancy_loss(x): mean_rgb = tf.reduce_mean(x, axis=(1, 2), keepdims=True) mr, mg, mb = mean_rgb[:, :, :, 0], mean_rgb[:, :, :, 1], mean_rgb[:, :, :, 2] d_rg = tf.square(mr - mg) d_rb = tf.square(mr - mb) d_gb = tf.square(mb - mg) return tf.sqrt(tf.square(d_rg) + tf.square(d_rb) + tf.square(d_gb)) Exposure loss To restrain under-/over-exposed regions, we use the exposure control loss. It measures the distance between the average intensity value of a local region and a preset well-exposedness level (set to 0.6). def exposure_loss(x, mean_val=0.6): x = tf.reduce_mean(x, axis=3, keepdims=True) mean = tf.nn.avg_pool2d(x, ksize=16, strides=16, padding=\"VALID\") return tf.reduce_mean(tf.square(mean - mean_val)) Illumination smoothness loss To preserve the monotonicity relations between neighboring pixels, the illumination smoothness loss is added to each curve parameter map. def illumination_smoothness_loss(x): batch_size = tf.shape(x)[0] h_x = tf.shape(x)[1] w_x = tf.shape(x)[2] count_h = (tf.shape(x)[2] - 1) * tf.shape(x)[3] count_w = tf.shape(x)[2] * (tf.shape(x)[3] - 1) h_tv = tf.reduce_sum(tf.square((x[:, 1:, :, :] - x[:, : h_x - 1, :, :]))) w_tv = tf.reduce_sum(tf.square((x[:, :, 1:, :] - x[:, :, : w_x - 1, :]))) batch_size = tf.cast(batch_size, dtype=tf.float32) count_h = tf.cast(count_h, dtype=tf.float32) count_w = tf.cast(count_w, dtype=tf.float32) return 2 * (h_tv / count_h + w_tv / count_w) / batch_size Spatial consistency loss The spatial consistency loss encourages spatial coherence of the enhanced image by preserving the contrast between neighboring regions across the input image and its enhanced version. class SpatialConsistencyLoss(keras.losses.Loss): def __init__(self, **kwargs): super(SpatialConsistencyLoss, self).__init__(reduction=\"none\") self.left_kernel = tf.constant( [[[[0, 0, 0]], [[-1, 1, 0]], [[0, 0, 0]]]], dtype=tf.float32 ) self.right_kernel = tf.constant( [[[[0, 0, 0]], [[0, 1, -1]], [[0, 0, 0]]]], dtype=tf.float32 ) self.up_kernel = tf.constant( [[[[0, -1, 0]], [[0, 1, 0]], [[0, 0, 0]]]], dtype=tf.float32 ) self.down_kernel = tf.constant( [[[[0, 0, 0]], [[0, 1, 0]], [[0, -1, 0]]]], dtype=tf.float32 ) def call(self, y_true, y_pred): original_mean = tf.reduce_mean(y_true, 3, keepdims=True) enhanced_mean = tf.reduce_mean(y_pred, 3, keepdims=True) original_pool = tf.nn.avg_pool2d( original_mean, ksize=4, strides=4, padding=\"VALID\" ) enhanced_pool = tf.nn.avg_pool2d( enhanced_mean, ksize=4, strides=4, padding=\"VALID\" ) d_original_left = tf.nn.conv2d( original_pool, self.left_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_original_right = tf.nn.conv2d( original_pool, self.right_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_original_up = tf.nn.conv2d( original_pool, self.up_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_original_down = tf.nn.conv2d( original_pool, self.down_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_enhanced_left = tf.nn.conv2d( enhanced_pool, self.left_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_enhanced_right = tf.nn.conv2d( enhanced_pool, self.right_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_enhanced_up = tf.nn.conv2d( enhanced_pool, self.up_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_enhanced_down = tf.nn.conv2d( enhanced_pool, self.down_kernel, strides=[1, 1, 1, 1], padding=\"SAME\" ) d_left = tf.square(d_original_left - d_enhanced_left) d_right = tf.square(d_original_right - d_enhanced_right) d_up = tf.square(d_original_up - d_enhanced_up) d_down = tf.square(d_original_down - d_enhanced_down) return d_left + d_right + d_up + d_down Deep curve estimation model We implement the Zero-DCE framework as a Keras subclassed model. class ZeroDCE(keras.Model): def __init__(self, **kwargs): super(ZeroDCE, self).__init__(**kwargs) self.dce_model = build_dce_net() def compile(self, learning_rate, **kwargs): super(ZeroDCE, self).compile(**kwargs) self.optimizer = keras.optimizers.Adam(learning_rate=learning_rate) self.spatial_constancy_loss = SpatialConsistencyLoss(reduction=\"none\") def get_enhanced_image(self, data, output): r1 = output[:, :, :, :3] r2 = output[:, :, :, 3:6] r3 = output[:, :, :, 6:9] r4 = output[:, :, :, 9:12] r5 = output[:, :, :, 12:15] r6 = output[:, :, :, 15:18] r7 = output[:, :, :, 18:21] r8 = output[:, :, :, 21:24] x = data + r1 * (tf.square(data) - data) x = x + r2 * (tf.square(x) - x) x = x + r3 * (tf.square(x) - x) enhanced_image = x + r4 * (tf.square(x) - x) x = enhanced_image + r5 * (tf.square(enhanced_image) - enhanced_image) x = x + r6 * (tf.square(x) - x) x = x + r7 * (tf.square(x) - x) enhanced_image = x + r8 * (tf.square(x) - x) return enhanced_image def call(self, data): dce_net_output = self.dce_model(data) return self.get_enhanced_image(data, dce_net_output) def compute_losses(self, data, output): enhanced_image = self.get_enhanced_image(data, output) loss_illumination = 200 * illumination_smoothness_loss(output) loss_spatial_constancy = tf.reduce_mean( self.spatial_constancy_loss(enhanced_image, data) ) loss_color_constancy = 5 * tf.reduce_mean(color_constancy_loss(enhanced_image)) loss_exposure = 10 * tf.reduce_mean(exposure_loss(enhanced_image)) total_loss = ( loss_illumination + loss_spatial_constancy + loss_color_constancy + loss_exposure ) return { \"total_loss\": total_loss, \"illumination_smoothness_loss\": loss_illumination, \"spatial_constancy_loss\": loss_spatial_constancy, \"color_constancy_loss\": loss_color_constancy, \"exposure_loss\": loss_exposure, } def train_step(self, data): with tf.GradientTape() as tape: output = self.dce_model(data) losses = self.compute_losses(data, output) gradients = tape.gradient( losses[\"total_loss\"], self.dce_model.trainable_weights ) self.optimizer.apply_gradients(zip(gradients, self.dce_model.trainable_weights)) return losses def test_step(self, data): output = self.dce_model(data) return self.compute_losses(data, output) def save_weights(self, filepath, overwrite=True, save_format=None, options=None): \"\"\"While saving the weights, we simply save the weights of the DCE-Net\"\"\" self.dce_model.save_weights( filepath, overwrite=overwrite, save_format=save_format, options=options ) def load_weights(self, filepath, by_name=False, skip_mismatch=False, options=None): \"\"\"While loading the weights, we simply load the weights of the DCE-Net\"\"\" self.dce_model.load_weights( filepath=filepath, by_name=by_name, skip_mismatch=skip_mismatch, options=options, ) Training zero_dce_model = ZeroDCE() zero_dce_model.compile(learning_rate=1e-4) history = zero_dce_model.fit(train_dataset, validation_data=val_dataset, epochs=100) def plot_result(item): plt.plot(history.history[item], label=item) plt.plot(history.history[\"val_\" + item], label=\"val_\" + item) plt.xlabel(\"Epochs\") plt.ylabel(item) plt.title(\"Train and Validation {} Over Epochs\".format(item), fontsize=14) plt.legend() plt.grid() plt.show() plot_result(\"total_loss\") plot_result(\"illumination_smoothness_loss\") plot_result(\"spatial_constancy_loss\") plot_result(\"color_constancy_loss\") plot_result(\"exposure_loss\") Epoch 1/100 25/25 [==============================] - 13s 271ms/step - total_loss: 4.8773 - illumination_smoothness_loss: 1.9298 - spatial_constancy_loss: 4.2610e-06 - color_constancy_loss: 0.0027 - exposure_loss: 2.9448 - val_total_loss: 4.3163 - val_illumination_smoothness_loss: 1.3040 - val_spatial_constancy_loss: 1.4072e-06 - val_color_constancy_loss: 5.3277e-04 - val_exposure_loss: 3.0117 Epoch 2/100 25/25 [==============================] - 7s 270ms/step - total_loss: 4.1537 - illumination_smoothness_loss: 1.2237 - spatial_constancy_loss: 6.5297e-06 - color_constancy_loss: 0.0027 - exposure_loss: 2.9273 - val_total_loss: 3.8239 - val_illumination_smoothness_loss: 0.8263 - val_spatial_constancy_loss: 1.3503e-05 - val_color_constancy_loss: 4.8064e-04 - val_exposure_loss: 2.9971 Epoch 3/100 25/25 [==============================] - 7s 270ms/step - total_loss: 3.7458 - illumination_smoothness_loss: 0.8320 - spatial_constancy_loss: 2.9476e-05 - color_constancy_loss: 0.0028 - exposure_loss: 2.9110 - val_total_loss: 3.5389 - val_illumination_smoothness_loss: 0.5565 - val_spatial_constancy_loss: 4.3614e-05 - val_color_constancy_loss: 4.4507e-04 - val_exposure_loss: 2.9818 Epoch 4/100 25/25 [==============================] - 7s 271ms/step - total_loss: 3.4913 - illumination_smoothness_loss: 0.5945 - spatial_constancy_loss: 7.2733e-05 - color_constancy_loss: 0.0029 - exposure_loss: 2.8939 - val_total_loss: 3.3690 - val_illumination_smoothness_loss: 0.4014 - val_spatial_constancy_loss: 8.7945e-05 - val_color_constancy_loss: 4.3541e-04 - val_exposure_loss: 2.9671 Epoch 5/100 25/25 [==============================] - 7s 271ms/step - total_loss: 3.3210 - illumination_smoothness_loss: 0.4399 - spatial_constancy_loss: 1.2652e-04 - color_constancy_loss: 0.0030 - exposure_loss: 2.8781 - val_total_loss: 3.2557 - val_illumination_smoothness_loss: 0.3019 - val_spatial_constancy_loss: 1.3960e-04 - val_color_constancy_loss: 4.4128e-04 - val_exposure_loss: 2.9533 Epoch 6/100 25/25 [==============================] - 7s 272ms/step - total_loss: 3.1971 - illumination_smoothness_loss: 0.3310 - spatial_constancy_loss: 1.8674e-04 - color_constancy_loss: 0.0031 - exposure_loss: 2.8628 - val_total_loss: 3.1741 - val_illumination_smoothness_loss: 0.2338 - val_spatial_constancy_loss: 1.9747e-04 - val_color_constancy_loss: 4.5618e-04 - val_exposure_loss: 2.9397 Epoch 7/100 25/25 [==============================] - 7s 263ms/step - total_loss: 3.1008 - illumination_smoothness_loss: 0.2506 - spatial_constancy_loss: 2.5713e-04 - color_constancy_loss: 0.0032 - exposure_loss: 2.8468 - val_total_loss: 3.1062 - val_illumination_smoothness_loss: 0.1804 - val_spatial_constancy_loss: 2.6610e-04 - val_color_constancy_loss: 4.7632e-04 - val_exposure_loss: 2.9251 Epoch 8/100 25/25 [==============================] - 7s 272ms/step - total_loss: 3.0244 - illumination_smoothness_loss: 0.1915 - spatial_constancy_loss: 3.4287e-04 - color_constancy_loss: 0.0033 - exposure_loss: 2.8293 - val_total_loss: 3.0512 - val_illumination_smoothness_loss: 0.1415 - val_spatial_constancy_loss: 3.5449e-04 - val_color_constancy_loss: 5.0079e-04 - val_exposure_loss: 2.9088 Epoch 9/100 25/25 [==============================] - 7s 272ms/step - total_loss: 2.9666 - illumination_smoothness_loss: 0.1531 - spatial_constancy_loss: 4.5557e-04 - color_constancy_loss: 0.0035 - exposure_loss: 2.8096 - val_total_loss: 3.0084 - val_illumination_smoothness_loss: 0.1172 - val_spatial_constancy_loss: 4.7605e-04 - val_color_constancy_loss: 5.3119e-04 - val_exposure_loss: 2.8902 Epoch 10/100 25/25 [==============================] - 7s 263ms/step - total_loss: 2.9216 - illumination_smoothness_loss: 0.1294 - spatial_constancy_loss: 6.0396e-04 - color_constancy_loss: 0.0037 - exposure_loss: 2.7879 - val_total_loss: 2.9737 - val_illumination_smoothness_loss: 0.1028 - val_spatial_constancy_loss: 6.3615e-04 - val_color_constancy_loss: 5.6798e-04 - val_exposure_loss: 2.8697 Epoch 11/100 25/25 [==============================] - 7s 264ms/step - total_loss: 2.8823 - illumination_smoothness_loss: 0.1141 - spatial_constancy_loss: 8.0172e-04 - color_constancy_loss: 0.0039 - exposure_loss: 2.7635 - val_total_loss: 2.9422 - val_illumination_smoothness_loss: 0.0951 - val_spatial_constancy_loss: 8.5813e-04 - val_color_constancy_loss: 6.1538e-04 - val_exposure_loss: 2.8456 Epoch 12/100 25/25 [==============================] - 7s 273ms/step - total_loss: 2.8443 - illumination_smoothness_loss: 0.1049 - spatial_constancy_loss: 0.0011 - color_constancy_loss: 0.0043 - exposure_loss: 2.7341 - val_total_loss: 2.9096 - val_illumination_smoothness_loss: 0.0936 - val_spatial_constancy_loss: 0.0012 - val_color_constancy_loss: 6.7707e-04 - val_exposure_loss: 2.8142 Epoch 13/100 25/25 [==============================] - 7s 274ms/step - total_loss: 2.7997 - illumination_smoothness_loss: 0.1031 - spatial_constancy_loss: 0.0016 - color_constancy_loss: 0.0047 - exposure_loss: 2.6903 - val_total_loss: 2.8666 - val_illumination_smoothness_loss: 0.1034 - val_spatial_constancy_loss: 0.0019 - val_color_constancy_loss: 8.0413e-04 - val_exposure_loss: 2.7604 Epoch 14/100 25/25 [==============================] - 7s 275ms/step - total_loss: 2.7249 - illumination_smoothness_loss: 0.1149 - spatial_constancy_loss: 0.0030 - color_constancy_loss: 0.0057 - exposure_loss: 2.6013 - val_total_loss: 2.7764 - val_illumination_smoothness_loss: 0.1291 - val_spatial_constancy_loss: 0.0042 - val_color_constancy_loss: 0.0011 - val_exposure_loss: 2.6419 Epoch 15/100 25/25 [==============================] - 7s 265ms/step - total_loss: 2.5184 - illumination_smoothness_loss: 0.1584 - spatial_constancy_loss: 0.0103 - color_constancy_loss: 0.0093 - exposure_loss: 2.3403 - val_total_loss: 2.4698 - val_illumination_smoothness_loss: 0.1949 - val_spatial_constancy_loss: 0.0194 - val_color_constancy_loss: 0.0031 - val_exposure_loss: 2.2524 Epoch 16/100 25/25 [==============================] - 7s 275ms/step - total_loss: 1.8216 - illumination_smoothness_loss: 0.2401 - spatial_constancy_loss: 0.0934 - color_constancy_loss: 0.0348 - exposure_loss: 1.4532 - val_total_loss: 1.6855 - val_illumination_smoothness_loss: 0.2599 - val_spatial_constancy_loss: 0.1776 - val_color_constancy_loss: 0.0229 - val_exposure_loss: 1.2250 Epoch 17/100 25/25 [==============================] - 7s 267ms/step - total_loss: 1.3387 - illumination_smoothness_loss: 0.2350 - spatial_constancy_loss: 0.2752 - color_constancy_loss: 0.0814 - exposure_loss: 0.7471 - val_total_loss: 1.5451 - val_illumination_smoothness_loss: 0.1862 - val_spatial_constancy_loss: 0.2320 - val_color_constancy_loss: 0.0331 - val_exposure_loss: 1.0938 Epoch 18/100 25/25 [==============================] - 7s 267ms/step - total_loss: 1.2646 - illumination_smoothness_loss: 0.1724 - spatial_constancy_loss: 0.2605 - color_constancy_loss: 0.0720 - exposure_loss: 0.7597 - val_total_loss: 1.5153 - val_illumination_smoothness_loss: 0.1533 - val_spatial_constancy_loss: 0.2295 - val_color_constancy_loss: 0.0343 - val_exposure_loss: 1.0981 Epoch 19/100 25/25 [==============================] - 7s 267ms/step - total_loss: 1.2439 - illumination_smoothness_loss: 0.1559 - spatial_constancy_loss: 0.2706 - color_constancy_loss: 0.0730 - exposure_loss: 0.7443 - val_total_loss: 1.4994 - val_illumination_smoothness_loss: 0.1423 - val_spatial_constancy_loss: 0.2359 - val_color_constancy_loss: 0.0363 - val_exposure_loss: 1.0850 Epoch 20/100 25/25 [==============================] - 7s 276ms/step - total_loss: 1.2311 - illumination_smoothness_loss: 0.1449 - spatial_constancy_loss: 0.2720 - color_constancy_loss: 0.0731 - exposure_loss: 0.7411 - val_total_loss: 1.4889 - val_illumination_smoothness_loss: 0.1299 - val_spatial_constancy_loss: 0.2331 - val_color_constancy_loss: 0.0358 - val_exposure_loss: 1.0901 Epoch 21/100 25/25 [==============================] - 7s 266ms/step - total_loss: 1.2262 - illumination_smoothness_loss: 0.1400 - spatial_constancy_loss: 0.2726 - color_constancy_loss: 0.0734 - exposure_loss: 0.7402 - val_total_loss: 1.4806 - val_illumination_smoothness_loss: 0.1233 - val_spatial_constancy_loss: 0.2356 - val_color_constancy_loss: 0.0371 - val_exposure_loss: 1.0847 Epoch 22/100 25/25 [==============================] - 7s 266ms/step - total_loss: 1.2202 - illumination_smoothness_loss: 0.1325 - spatial_constancy_loss: 0.2739 - color_constancy_loss: 0.0734 - exposure_loss: 0.7404 - val_total_loss: 1.4765 - val_illumination_smoothness_loss: 0.1231 - val_spatial_constancy_loss: 0.2408 - val_color_constancy_loss: 0.0381 - val_exposure_loss: 1.0745 Epoch 23/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.2122 - illumination_smoothness_loss: 0.1247 - spatial_constancy_loss: 0.2752 - color_constancy_loss: 0.0739 - exposure_loss: 0.7384 - val_total_loss: 1.4757 - val_illumination_smoothness_loss: 0.1253 - val_spatial_constancy_loss: 0.2453 - val_color_constancy_loss: 0.0393 - val_exposure_loss: 1.0658 Epoch 24/100 25/25 [==============================] - 7s 276ms/step - total_loss: 1.2015 - illumination_smoothness_loss: 0.1149 - spatial_constancy_loss: 0.2766 - color_constancy_loss: 0.0740 - exposure_loss: 0.7360 - val_total_loss: 1.4667 - val_illumination_smoothness_loss: 0.1168 - val_spatial_constancy_loss: 0.2456 - val_color_constancy_loss: 0.0390 - val_exposure_loss: 1.0652 Epoch 25/100 25/25 [==============================] - 7s 267ms/step - total_loss: 1.1940 - illumination_smoothness_loss: 0.1087 - spatial_constancy_loss: 0.2783 - color_constancy_loss: 0.0746 - exposure_loss: 0.7324 - val_total_loss: 1.4597 - val_illumination_smoothness_loss: 0.1109 - val_spatial_constancy_loss: 0.2476 - val_color_constancy_loss: 0.0399 - val_exposure_loss: 1.0613 Epoch 26/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.1878 - illumination_smoothness_loss: 0.1028 - spatial_constancy_loss: 0.2800 - color_constancy_loss: 0.0748 - exposure_loss: 0.7302 - val_total_loss: 1.4537 - val_illumination_smoothness_loss: 0.1054 - val_spatial_constancy_loss: 0.2479 - val_color_constancy_loss: 0.0398 - val_exposure_loss: 1.0606 Epoch 27/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.1827 - illumination_smoothness_loss: 0.0979 - spatial_constancy_loss: 0.2802 - color_constancy_loss: 0.0750 - exposure_loss: 0.7296 - val_total_loss: 1.4488 - val_illumination_smoothness_loss: 0.1015 - val_spatial_constancy_loss: 0.2496 - val_color_constancy_loss: 0.0404 - val_exposure_loss: 1.0573 Epoch 28/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.1774 - illumination_smoothness_loss: 0.0928 - spatial_constancy_loss: 0.2814 - color_constancy_loss: 0.0749 - exposure_loss: 0.7283 - val_total_loss: 1.4439 - val_illumination_smoothness_loss: 0.0968 - val_spatial_constancy_loss: 0.2491 - val_color_constancy_loss: 0.0397 - val_exposure_loss: 1.0583 Epoch 29/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.1720 - illumination_smoothness_loss: 0.0882 - spatial_constancy_loss: 0.2821 - color_constancy_loss: 0.0754 - exposure_loss: 0.7264 - val_total_loss: 1.4372 - val_illumination_smoothness_loss: 0.0907 - val_spatial_constancy_loss: 0.2504 - val_color_constancy_loss: 0.0405 - val_exposure_loss: 1.0557 Epoch 30/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.1660 - illumination_smoothness_loss: 0.0825 - spatial_constancy_loss: 0.2841 - color_constancy_loss: 0.0757 - exposure_loss: 0.7238 - val_total_loss: 1.4307 - val_illumination_smoothness_loss: 0.0840 - val_spatial_constancy_loss: 0.2500 - val_color_constancy_loss: 0.0406 - val_exposure_loss: 1.0561 Epoch 31/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.1626 - illumination_smoothness_loss: 0.0790 - spatial_constancy_loss: 0.2834 - color_constancy_loss: 0.0753 - exposure_loss: 0.7248 - val_total_loss: 1.4285 - val_illumination_smoothness_loss: 0.0829 - val_spatial_constancy_loss: 0.2508 - val_color_constancy_loss: 0.0399 - val_exposure_loss: 1.0549 Epoch 32/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.1576 - illumination_smoothness_loss: 0.0744 - spatial_constancy_loss: 0.2851 - color_constancy_loss: 0.0759 - exposure_loss: 0.7222 - val_total_loss: 1.4213 - val_illumination_smoothness_loss: 0.0756 - val_spatial_constancy_loss: 0.2509 - val_color_constancy_loss: 0.0403 - val_exposure_loss: 1.0545 Epoch 33/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.1529 - illumination_smoothness_loss: 0.0702 - spatial_constancy_loss: 0.2856 - color_constancy_loss: 0.0757 - exposure_loss: 0.7215 - val_total_loss: 1.4164 - val_illumination_smoothness_loss: 0.0720 - val_spatial_constancy_loss: 0.2525 - val_color_constancy_loss: 0.0403 - val_exposure_loss: 1.0515 Epoch 34/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.1486 - illumination_smoothness_loss: 0.0659 - spatial_constancy_loss: 0.2871 - color_constancy_loss: 0.0762 - exposure_loss: 0.7195 - val_total_loss: 1.4120 - val_illumination_smoothness_loss: 0.0675 - val_spatial_constancy_loss: 0.2528 - val_color_constancy_loss: 0.0410 - val_exposure_loss: 1.0507 Epoch 35/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.1439 - illumination_smoothness_loss: 0.0617 - spatial_constancy_loss: 0.2876 - color_constancy_loss: 0.0761 - exposure_loss: 0.7184 - val_total_loss: 1.4064 - val_illumination_smoothness_loss: 0.0628 - val_spatial_constancy_loss: 0.2538 - val_color_constancy_loss: 0.0408 - val_exposure_loss: 1.0490 Epoch 36/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.1393 - illumination_smoothness_loss: 0.0575 - spatial_constancy_loss: 0.2891 - color_constancy_loss: 0.0766 - exposure_loss: 0.7161 - val_total_loss: 1.4016 - val_illumination_smoothness_loss: 0.0574 - val_spatial_constancy_loss: 0.2529 - val_color_constancy_loss: 0.0408 - val_exposure_loss: 1.0505 Epoch 37/100 25/25 [==============================] - 7s 270ms/step - total_loss: 1.1360 - illumination_smoothness_loss: 0.0539 - spatial_constancy_loss: 0.2891 - color_constancy_loss: 0.0763 - exposure_loss: 0.7166 - val_total_loss: 1.3975 - val_illumination_smoothness_loss: 0.0545 - val_spatial_constancy_loss: 0.2547 - val_color_constancy_loss: 0.0410 - val_exposure_loss: 1.0473 Epoch 38/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.1327 - illumination_smoothness_loss: 0.0512 - spatial_constancy_loss: 0.2907 - color_constancy_loss: 0.0770 - exposure_loss: 0.7138 - val_total_loss: 1.3946 - val_illumination_smoothness_loss: 0.0515 - val_spatial_constancy_loss: 0.2546 - val_color_constancy_loss: 0.0414 - val_exposure_loss: 1.0471 Epoch 39/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.1283 - illumination_smoothness_loss: 0.0465 - spatial_constancy_loss: 0.2916 - color_constancy_loss: 0.0768 - exposure_loss: 0.7133 - val_total_loss: 1.3906 - val_illumination_smoothness_loss: 0.0473 - val_spatial_constancy_loss: 0.2538 - val_color_constancy_loss: 0.0411 - val_exposure_loss: 1.0485 Epoch 40/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.1257 - illumination_smoothness_loss: 0.0441 - spatial_constancy_loss: 0.2907 - color_constancy_loss: 0.0768 - exposure_loss: 0.7141 - val_total_loss: 1.3889 - val_illumination_smoothness_loss: 0.0477 - val_spatial_constancy_loss: 0.2577 - val_color_constancy_loss: 0.0419 - val_exposure_loss: 1.0416 Epoch 41/100 25/25 [==============================] - 7s 271ms/step - total_loss: 1.1225 - illumination_smoothness_loss: 0.0412 - spatial_constancy_loss: 0.2928 - color_constancy_loss: 0.0772 - exposure_loss: 0.7114 - val_total_loss: 1.3848 - val_illumination_smoothness_loss: 0.0433 - val_spatial_constancy_loss: 0.2569 - val_color_constancy_loss: 0.0417 - val_exposure_loss: 1.0428 Epoch 42/100 25/25 [==============================] - 7s 270ms/step - total_loss: 1.1202 - illumination_smoothness_loss: 0.0391 - spatial_constancy_loss: 0.2929 - color_constancy_loss: 0.0771 - exposure_loss: 0.7110 - val_total_loss: 1.3831 - val_illumination_smoothness_loss: 0.0425 - val_spatial_constancy_loss: 0.2583 - val_color_constancy_loss: 0.0420 - val_exposure_loss: 1.0403 Epoch 43/100 25/25 [==============================] - 7s 270ms/step - total_loss: 1.1177 - illumination_smoothness_loss: 0.0365 - spatial_constancy_loss: 0.2932 - color_constancy_loss: 0.0772 - exposure_loss: 0.7107 - val_total_loss: 1.3784 - val_illumination_smoothness_loss: 0.0376 - val_spatial_constancy_loss: 0.2578 - val_color_constancy_loss: 0.0418 - val_exposure_loss: 1.0412 Epoch 44/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.1155 - illumination_smoothness_loss: 0.0349 - spatial_constancy_loss: 0.2953 - color_constancy_loss: 0.0777 - exposure_loss: 0.7077 - val_total_loss: 1.3767 - val_illumination_smoothness_loss: 0.0341 - val_spatial_constancy_loss: 0.2545 - val_color_constancy_loss: 0.0413 - val_exposure_loss: 1.0467 Epoch 45/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.1133 - illumination_smoothness_loss: 0.0321 - spatial_constancy_loss: 0.2931 - color_constancy_loss: 0.0770 - exposure_loss: 0.7110 - val_total_loss: 1.3755 - val_illumination_smoothness_loss: 0.0353 - val_spatial_constancy_loss: 0.2590 - val_color_constancy_loss: 0.0424 - val_exposure_loss: 1.0387 Epoch 46/100 25/25 [==============================] - 7s 280ms/step - total_loss: 1.1112 - illumination_smoothness_loss: 0.0304 - spatial_constancy_loss: 0.2952 - color_constancy_loss: 0.0776 - exposure_loss: 0.7080 - val_total_loss: 1.3728 - val_illumination_smoothness_loss: 0.0328 - val_spatial_constancy_loss: 0.2591 - val_color_constancy_loss: 0.0424 - val_exposure_loss: 1.0385 Epoch 47/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.1094 - illumination_smoothness_loss: 0.0287 - spatial_constancy_loss: 0.2955 - color_constancy_loss: 0.0775 - exposure_loss: 0.7076 - val_total_loss: 1.3720 - val_illumination_smoothness_loss: 0.0329 - val_spatial_constancy_loss: 0.2605 - val_color_constancy_loss: 0.0425 - val_exposure_loss: 1.0361 Epoch 48/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.1079 - illumination_smoothness_loss: 0.0276 - spatial_constancy_loss: 0.2955 - color_constancy_loss: 0.0777 - exposure_loss: 0.7072 - val_total_loss: 1.3707 - val_illumination_smoothness_loss: 0.0316 - val_spatial_constancy_loss: 0.2606 - val_color_constancy_loss: 0.0426 - val_exposure_loss: 1.0359 Epoch 49/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.1056 - illumination_smoothness_loss: 0.0252 - spatial_constancy_loss: 0.2967 - color_constancy_loss: 0.0777 - exposure_loss: 0.7061 - val_total_loss: 1.3672 - val_illumination_smoothness_loss: 0.0277 - val_spatial_constancy_loss: 0.2597 - val_color_constancy_loss: 0.0426 - val_exposure_loss: 1.0372 Epoch 50/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.1047 - illumination_smoothness_loss: 0.0243 - spatial_constancy_loss: 0.2962 - color_constancy_loss: 0.0776 - exposure_loss: 0.7066 - val_total_loss: 1.3653 - val_illumination_smoothness_loss: 0.0256 - val_spatial_constancy_loss: 0.2590 - val_color_constancy_loss: 0.0423 - val_exposure_loss: 1.0383 Epoch 51/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.1038 - illumination_smoothness_loss: 0.0237 - spatial_constancy_loss: 0.2968 - color_constancy_loss: 0.0778 - exposure_loss: 0.7054 - val_total_loss: 1.3657 - val_illumination_smoothness_loss: 0.0273 - val_spatial_constancy_loss: 0.2617 - val_color_constancy_loss: 0.0431 - val_exposure_loss: 1.0335 Epoch 52/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.1020 - illumination_smoothness_loss: 0.0220 - spatial_constancy_loss: 0.2979 - color_constancy_loss: 0.0779 - exposure_loss: 0.7042 - val_total_loss: 1.3635 - val_illumination_smoothness_loss: 0.0234 - val_spatial_constancy_loss: 0.2579 - val_color_constancy_loss: 0.0422 - val_exposure_loss: 1.0400 Epoch 53/100 25/25 [==============================] - 7s 270ms/step - total_loss: 1.1012 - illumination_smoothness_loss: 0.0208 - spatial_constancy_loss: 0.2967 - color_constancy_loss: 0.0775 - exposure_loss: 0.7064 - val_total_loss: 1.3636 - val_illumination_smoothness_loss: 0.0250 - val_spatial_constancy_loss: 0.2607 - val_color_constancy_loss: 0.0428 - val_exposure_loss: 1.0352 Epoch 54/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.1002 - illumination_smoothness_loss: 0.0205 - spatial_constancy_loss: 0.2970 - color_constancy_loss: 0.0777 - exposure_loss: 0.7049 - val_total_loss: 1.3615 - val_illumination_smoothness_loss: 0.0233 - val_spatial_constancy_loss: 0.2611 - val_color_constancy_loss: 0.0427 - val_exposure_loss: 1.0345 Epoch 55/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0989 - illumination_smoothness_loss: 0.0193 - spatial_constancy_loss: 0.2985 - color_constancy_loss: 0.0780 - exposure_loss: 0.7032 - val_total_loss: 1.3608 - val_illumination_smoothness_loss: 0.0225 - val_spatial_constancy_loss: 0.2609 - val_color_constancy_loss: 0.0428 - val_exposure_loss: 1.0346 Epoch 56/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0986 - illumination_smoothness_loss: 0.0190 - spatial_constancy_loss: 0.2971 - color_constancy_loss: 0.0777 - exposure_loss: 0.7048 - val_total_loss: 1.3615 - val_illumination_smoothness_loss: 0.0238 - val_spatial_constancy_loss: 0.2621 - val_color_constancy_loss: 0.0430 - val_exposure_loss: 1.0327 Epoch 57/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.0977 - illumination_smoothness_loss: 0.0182 - spatial_constancy_loss: 0.2987 - color_constancy_loss: 0.0780 - exposure_loss: 0.7028 - val_total_loss: 1.3601 - val_illumination_smoothness_loss: 0.0226 - val_spatial_constancy_loss: 0.2623 - val_color_constancy_loss: 0.0431 - val_exposure_loss: 1.0321 Epoch 58/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0971 - illumination_smoothness_loss: 0.0174 - spatial_constancy_loss: 0.2979 - color_constancy_loss: 0.0778 - exposure_loss: 0.7040 - val_total_loss: 1.3596 - val_illumination_smoothness_loss: 0.0218 - val_spatial_constancy_loss: 0.2615 - val_color_constancy_loss: 0.0428 - val_exposure_loss: 1.0334 Epoch 59/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0974 - illumination_smoothness_loss: 0.0180 - spatial_constancy_loss: 0.2985 - color_constancy_loss: 0.0780 - exposure_loss: 0.7029 - val_total_loss: 1.3611 - val_illumination_smoothness_loss: 0.0246 - val_spatial_constancy_loss: 0.2645 - val_color_constancy_loss: 0.0437 - val_exposure_loss: 1.0282 Epoch 60/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0956 - illumination_smoothness_loss: 0.0165 - spatial_constancy_loss: 0.2985 - color_constancy_loss: 0.0780 - exposure_loss: 0.7026 - val_total_loss: 1.3581 - val_illumination_smoothness_loss: 0.0209 - val_spatial_constancy_loss: 0.2623 - val_color_constancy_loss: 0.0430 - val_exposure_loss: 1.0320 Epoch 61/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0953 - illumination_smoothness_loss: 0.0159 - spatial_constancy_loss: 0.2992 - color_constancy_loss: 0.0782 - exposure_loss: 0.7020 - val_total_loss: 1.3579 - val_illumination_smoothness_loss: 0.0213 - val_spatial_constancy_loss: 0.2637 - val_color_constancy_loss: 0.0436 - val_exposure_loss: 1.0293 Epoch 62/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.0945 - illumination_smoothness_loss: 0.0154 - spatial_constancy_loss: 0.2982 - color_constancy_loss: 0.0780 - exposure_loss: 0.7029 - val_total_loss: 1.3571 - val_illumination_smoothness_loss: 0.0199 - val_spatial_constancy_loss: 0.2620 - val_color_constancy_loss: 0.0429 - val_exposure_loss: 1.0323 Epoch 63/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0948 - illumination_smoothness_loss: 0.0156 - spatial_constancy_loss: 0.2989 - color_constancy_loss: 0.0781 - exposure_loss: 0.7021 - val_total_loss: 1.3577 - val_illumination_smoothness_loss: 0.0215 - val_spatial_constancy_loss: 0.2641 - val_color_constancy_loss: 0.0435 - val_exposure_loss: 1.0287 Epoch 64/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0935 - illumination_smoothness_loss: 0.0146 - spatial_constancy_loss: 0.2994 - color_constancy_loss: 0.0782 - exposure_loss: 0.7014 - val_total_loss: 1.3565 - val_illumination_smoothness_loss: 0.0200 - val_spatial_constancy_loss: 0.2632 - val_color_constancy_loss: 0.0433 - val_exposure_loss: 1.0300 Epoch 65/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0933 - illumination_smoothness_loss: 0.0144 - spatial_constancy_loss: 0.2992 - color_constancy_loss: 0.0781 - exposure_loss: 0.7015 - val_total_loss: 1.3570 - val_illumination_smoothness_loss: 0.0211 - val_spatial_constancy_loss: 0.2648 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0273 Epoch 66/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0927 - illumination_smoothness_loss: 0.0141 - spatial_constancy_loss: 0.2993 - color_constancy_loss: 0.0781 - exposure_loss: 0.7012 - val_total_loss: 1.3549 - val_illumination_smoothness_loss: 0.0179 - val_spatial_constancy_loss: 0.2618 - val_color_constancy_loss: 0.0429 - val_exposure_loss: 1.0323 Epoch 67/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0930 - illumination_smoothness_loss: 0.0141 - spatial_constancy_loss: 0.2992 - color_constancy_loss: 0.0781 - exposure_loss: 0.7016 - val_total_loss: 1.3565 - val_illumination_smoothness_loss: 0.0208 - val_spatial_constancy_loss: 0.2652 - val_color_constancy_loss: 0.0441 - val_exposure_loss: 1.0265 Epoch 68/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0919 - illumination_smoothness_loss: 0.0135 - spatial_constancy_loss: 0.3001 - color_constancy_loss: 0.0782 - exposure_loss: 0.7002 - val_total_loss: 1.3543 - val_illumination_smoothness_loss: 0.0173 - val_spatial_constancy_loss: 0.2617 - val_color_constancy_loss: 0.0429 - val_exposure_loss: 1.0323 Epoch 69/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0925 - illumination_smoothness_loss: 0.0136 - spatial_constancy_loss: 0.2989 - color_constancy_loss: 0.0780 - exposure_loss: 0.7019 - val_total_loss: 1.3562 - val_illumination_smoothness_loss: 0.0203 - val_spatial_constancy_loss: 0.2646 - val_color_constancy_loss: 0.0440 - val_exposure_loss: 1.0272 Epoch 70/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0916 - illumination_smoothness_loss: 0.0130 - spatial_constancy_loss: 0.3005 - color_constancy_loss: 0.0782 - exposure_loss: 0.7000 - val_total_loss: 1.3530 - val_illumination_smoothness_loss: 0.0156 - val_spatial_constancy_loss: 0.2606 - val_color_constancy_loss: 0.0428 - val_exposure_loss: 1.0341 Epoch 71/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0918 - illumination_smoothness_loss: 0.0128 - spatial_constancy_loss: 0.2985 - color_constancy_loss: 0.0778 - exposure_loss: 0.7028 - val_total_loss: 1.3550 - val_illumination_smoothness_loss: 0.0194 - val_spatial_constancy_loss: 0.2645 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0273 Epoch 72/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0911 - illumination_smoothness_loss: 0.0127 - spatial_constancy_loss: 0.3001 - color_constancy_loss: 0.0782 - exposure_loss: 0.7001 - val_total_loss: 1.3535 - val_illumination_smoothness_loss: 0.0175 - val_spatial_constancy_loss: 0.2638 - val_color_constancy_loss: 0.0438 - val_exposure_loss: 1.0284 Epoch 73/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0906 - illumination_smoothness_loss: 0.0121 - spatial_constancy_loss: 0.2998 - color_constancy_loss: 0.0780 - exposure_loss: 0.7006 - val_total_loss: 1.3521 - val_illumination_smoothness_loss: 0.0153 - val_spatial_constancy_loss: 0.2615 - val_color_constancy_loss: 0.0430 - val_exposure_loss: 1.0323 Epoch 74/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0914 - illumination_smoothness_loss: 0.0127 - spatial_constancy_loss: 0.2993 - color_constancy_loss: 0.0780 - exposure_loss: 0.7014 - val_total_loss: 1.3547 - val_illumination_smoothness_loss: 0.0189 - val_spatial_constancy_loss: 0.2642 - val_color_constancy_loss: 0.0441 - val_exposure_loss: 1.0275 Epoch 75/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0908 - illumination_smoothness_loss: 0.0125 - spatial_constancy_loss: 0.2994 - color_constancy_loss: 0.0781 - exposure_loss: 0.7008 - val_total_loss: 1.3533 - val_illumination_smoothness_loss: 0.0174 - val_spatial_constancy_loss: 0.2636 - val_color_constancy_loss: 0.0436 - val_exposure_loss: 1.0286 Epoch 76/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0909 - illumination_smoothness_loss: 0.0126 - spatial_constancy_loss: 0.2998 - color_constancy_loss: 0.0782 - exposure_loss: 0.7004 - val_total_loss: 1.3544 - val_illumination_smoothness_loss: 0.0194 - val_spatial_constancy_loss: 0.2655 - val_color_constancy_loss: 0.0442 - val_exposure_loss: 1.0253 Epoch 77/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0897 - illumination_smoothness_loss: 0.0116 - spatial_constancy_loss: 0.3002 - color_constancy_loss: 0.0783 - exposure_loss: 0.6996 - val_total_loss: 1.3516 - val_illumination_smoothness_loss: 0.0159 - val_spatial_constancy_loss: 0.2635 - val_color_constancy_loss: 0.0436 - val_exposure_loss: 1.0286 Epoch 78/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0900 - illumination_smoothness_loss: 0.0120 - spatial_constancy_loss: 0.2998 - color_constancy_loss: 0.0781 - exposure_loss: 0.7001 - val_total_loss: 1.3528 - val_illumination_smoothness_loss: 0.0174 - val_spatial_constancy_loss: 0.2641 - val_color_constancy_loss: 0.0437 - val_exposure_loss: 1.0277 Epoch 79/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.0904 - illumination_smoothness_loss: 0.0122 - spatial_constancy_loss: 0.2999 - color_constancy_loss: 0.0782 - exposure_loss: 0.7001 - val_total_loss: 1.3528 - val_illumination_smoothness_loss: 0.0178 - val_spatial_constancy_loss: 0.2647 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0264 Epoch 80/100 25/25 [==============================] - 7s 279ms/step - total_loss: 1.0895 - illumination_smoothness_loss: 0.0114 - spatial_constancy_loss: 0.2995 - color_constancy_loss: 0.0782 - exposure_loss: 0.7003 - val_total_loss: 1.3520 - val_illumination_smoothness_loss: 0.0168 - val_spatial_constancy_loss: 0.2643 - val_color_constancy_loss: 0.0438 - val_exposure_loss: 1.0270 Epoch 81/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0895 - illumination_smoothness_loss: 0.0116 - spatial_constancy_loss: 0.3002 - color_constancy_loss: 0.0783 - exposure_loss: 0.6995 - val_total_loss: 1.3520 - val_illumination_smoothness_loss: 0.0170 - val_spatial_constancy_loss: 0.2645 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0267 Epoch 82/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0898 - illumination_smoothness_loss: 0.0116 - spatial_constancy_loss: 0.3001 - color_constancy_loss: 0.0782 - exposure_loss: 0.6999 - val_total_loss: 1.3532 - val_illumination_smoothness_loss: 0.0185 - val_spatial_constancy_loss: 0.2655 - val_color_constancy_loss: 0.0443 - val_exposure_loss: 1.0249 Epoch 83/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0888 - illumination_smoothness_loss: 0.0112 - spatial_constancy_loss: 0.3002 - color_constancy_loss: 0.0782 - exposure_loss: 0.6992 - val_total_loss: 1.3517 - val_illumination_smoothness_loss: 0.0166 - val_spatial_constancy_loss: 0.2642 - val_color_constancy_loss: 0.0438 - val_exposure_loss: 1.0271 Epoch 84/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0887 - illumination_smoothness_loss: 0.0106 - spatial_constancy_loss: 0.3004 - color_constancy_loss: 0.0781 - exposure_loss: 0.6996 - val_total_loss: 1.3500 - val_illumination_smoothness_loss: 0.0148 - val_spatial_constancy_loss: 0.2639 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0275 Epoch 85/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0886 - illumination_smoothness_loss: 0.0110 - spatial_constancy_loss: 0.3000 - color_constancy_loss: 0.0781 - exposure_loss: 0.6994 - val_total_loss: 1.3511 - val_illumination_smoothness_loss: 0.0163 - val_spatial_constancy_loss: 0.2644 - val_color_constancy_loss: 0.0438 - val_exposure_loss: 1.0266 Epoch 86/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0889 - illumination_smoothness_loss: 0.0110 - spatial_constancy_loss: 0.3004 - color_constancy_loss: 0.0782 - exposure_loss: 0.6993 - val_total_loss: 1.3513 - val_illumination_smoothness_loss: 0.0166 - val_spatial_constancy_loss: 0.2649 - val_color_constancy_loss: 0.0442 - val_exposure_loss: 1.0257 Epoch 87/100 25/25 [==============================] - 7s 269ms/step - total_loss: 1.0885 - illumination_smoothness_loss: 0.0111 - spatial_constancy_loss: 0.3001 - color_constancy_loss: 0.0781 - exposure_loss: 0.6992 - val_total_loss: 1.3504 - val_illumination_smoothness_loss: 0.0154 - val_spatial_constancy_loss: 0.2639 - val_color_constancy_loss: 0.0437 - val_exposure_loss: 1.0274 Epoch 88/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0889 - illumination_smoothness_loss: 0.0111 - spatial_constancy_loss: 0.3000 - color_constancy_loss: 0.0781 - exposure_loss: 0.6997 - val_total_loss: 1.3512 - val_illumination_smoothness_loss: 0.0165 - val_spatial_constancy_loss: 0.2650 - val_color_constancy_loss: 0.0443 - val_exposure_loss: 1.0254 Epoch 89/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0883 - illumination_smoothness_loss: 0.0109 - spatial_constancy_loss: 0.3003 - color_constancy_loss: 0.0781 - exposure_loss: 0.6990 - val_total_loss: 1.3506 - val_illumination_smoothness_loss: 0.0160 - val_spatial_constancy_loss: 0.2645 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0262 Epoch 90/100 25/25 [==============================] - 7s 268ms/step - total_loss: 1.0883 - illumination_smoothness_loss: 0.0106 - spatial_constancy_loss: 0.3003 - color_constancy_loss: 0.0781 - exposure_loss: 0.6993 - val_total_loss: 1.3498 - val_illumination_smoothness_loss: 0.0149 - val_spatial_constancy_loss: 0.2640 - val_color_constancy_loss: 0.0440 - val_exposure_loss: 1.0270 Epoch 91/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.0883 - illumination_smoothness_loss: 0.0107 - spatial_constancy_loss: 0.3000 - color_constancy_loss: 0.0780 - exposure_loss: 0.6995 - val_total_loss: 1.3492 - val_illumination_smoothness_loss: 0.0146 - val_spatial_constancy_loss: 0.2644 - val_color_constancy_loss: 0.0440 - val_exposure_loss: 1.0262 Epoch 92/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0884 - illumination_smoothness_loss: 0.0108 - spatial_constancy_loss: 0.3007 - color_constancy_loss: 0.0782 - exposure_loss: 0.6987 - val_total_loss: 1.3496 - val_illumination_smoothness_loss: 0.0148 - val_spatial_constancy_loss: 0.2642 - val_color_constancy_loss: 0.0441 - val_exposure_loss: 1.0265 Epoch 93/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.0878 - illumination_smoothness_loss: 0.0105 - spatial_constancy_loss: 0.2994 - color_constancy_loss: 0.0780 - exposure_loss: 0.6999 - val_total_loss: 1.3497 - val_illumination_smoothness_loss: 0.0150 - val_spatial_constancy_loss: 0.2643 - val_color_constancy_loss: 0.0440 - val_exposure_loss: 1.0263 Epoch 94/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0876 - illumination_smoothness_loss: 0.0098 - spatial_constancy_loss: 0.3005 - color_constancy_loss: 0.0781 - exposure_loss: 0.6992 - val_total_loss: 1.3471 - val_illumination_smoothness_loss: 0.0120 - val_spatial_constancy_loss: 0.2633 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0279 Epoch 95/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0876 - illumination_smoothness_loss: 0.0103 - spatial_constancy_loss: 0.3002 - color_constancy_loss: 0.0782 - exposure_loss: 0.6989 - val_total_loss: 1.3493 - val_illumination_smoothness_loss: 0.0147 - val_spatial_constancy_loss: 0.2642 - val_color_constancy_loss: 0.0441 - val_exposure_loss: 1.0263 Epoch 96/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.0880 - illumination_smoothness_loss: 0.0105 - spatial_constancy_loss: 0.3001 - color_constancy_loss: 0.0781 - exposure_loss: 0.6994 - val_total_loss: 1.3485 - val_illumination_smoothness_loss: 0.0140 - val_spatial_constancy_loss: 0.2644 - val_color_constancy_loss: 0.0440 - val_exposure_loss: 1.0261 Epoch 97/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0878 - illumination_smoothness_loss: 0.0102 - spatial_constancy_loss: 0.3005 - color_constancy_loss: 0.0782 - exposure_loss: 0.6990 - val_total_loss: 1.3485 - val_illumination_smoothness_loss: 0.0140 - val_spatial_constancy_loss: 0.2645 - val_color_constancy_loss: 0.0443 - val_exposure_loss: 1.0257 Epoch 98/100 25/25 [==============================] - 7s 278ms/step - total_loss: 1.0875 - illumination_smoothness_loss: 0.0104 - spatial_constancy_loss: 0.3003 - color_constancy_loss: 0.0781 - exposure_loss: 0.6987 - val_total_loss: 1.3485 - val_illumination_smoothness_loss: 0.0140 - val_spatial_constancy_loss: 0.2641 - val_color_constancy_loss: 0.0440 - val_exposure_loss: 1.0264 Epoch 99/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.0879 - illumination_smoothness_loss: 0.0104 - spatial_constancy_loss: 0.3005 - color_constancy_loss: 0.0782 - exposure_loss: 0.6988 - val_total_loss: 1.3486 - val_illumination_smoothness_loss: 0.0140 - val_spatial_constancy_loss: 0.2642 - val_color_constancy_loss: 0.0443 - val_exposure_loss: 1.0260 Epoch 100/100 25/25 [==============================] - 7s 277ms/step - total_loss: 1.0873 - illumination_smoothness_loss: 0.0102 - spatial_constancy_loss: 0.3001 - color_constancy_loss: 0.0780 - exposure_loss: 0.6991 - val_total_loss: 1.3481 - val_illumination_smoothness_loss: 0.0134 - val_spatial_constancy_loss: 0.2635 - val_color_constancy_loss: 0.0439 - val_exposure_loss: 1.0273 png png png png png Inference def plot_results(images, titles, figure_size=(12, 12)): fig = plt.figure(figsize=figure_size) for i in range(len(images)): fig.add_subplot(1, len(images), i + 1).set_title(titles[i]) _ = plt.imshow(images[i]) plt.axis(\"off\") plt.show() def infer(original_image): image = keras.preprocessing.image.img_to_array(original_image) image = image.astype(\"float32\") / 255.0 image = np.expand_dims(image, axis=0) output_image = zero_dce_model(image) output_image = tf.cast((output_image[0, :, :, :] * 255), dtype=np.uint8) output_image = Image.fromarray(output_image.numpy()) return output_image Inference on test images We compare the test images from LOLDataset enhanced by MIRNet with images enhanced via the PIL.ImageOps.autocontrast() function. for val_image_file in test_low_light_images: original_image = Image.open(val_image_file) enhanced_image = infer(original_image) plot_results( [original_image, ImageOps.autocontrast(original_image), enhanced_image], [\"Original\", \"PIL Autocontrast\", \"Enhanced\"], (20, 12), ) png png png png png png png png png png png png png png png Generate text from Nietzche's writings with a character-level LSTM. Character-level text generation with LSTM Introduction This example demonstrates how to use a LSTM model to generate text character-by-character. At least 20 epochs are required before the generated text starts sounding locally coherent. It is recommended to run this script on GPU, as recurrent networks are quite computationally intensive. If you try this script on new data, make sure your corpus has at least ~100k characters. ~1M is better. Setup from tensorflow import keras from tensorflow.keras import layers import numpy as np import random import io Prepare the data path = keras.utils.get_file( \"nietzsche.txt\", origin=\"https://s3.amazonaws.com/text-datasets/nietzsche.txt\" ) with io.open(path, encoding=\"utf-8\") as f: text = f.read().lower() text = text.replace(\"\n\", \" \") # We remove newlines chars for nicer display print(\"Corpus length:\", len(text)) chars = sorted(list(set(text))) print(\"Total chars:\", len(chars)) char_indices = dict((c, i) for i, c in enumerate(chars)) indices_char = dict((i, c) for i, c in enumerate(chars)) # cut the text in semi-redundant sequences of maxlen characters maxlen = 40 step = 3 sentences = [] next_chars = [] for i in range(0, len(text) - maxlen, step): sentences.append(text[i : i + maxlen]) next_chars.append(text[i + maxlen]) print(\"Number of sequences:\", len(sentences)) x = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool) y = np.zeros((len(sentences), len(chars)), dtype=np.bool) for i, sentence in enumerate(sentences): for t, char in enumerate(sentence): x[i, t, char_indices[char]] = 1 y[i, char_indices[next_chars[i]]] = 1 Corpus length: 600893 Total chars: 56 Number of sequences: 200285 Build the model: a single LSTM layer model = keras.Sequential( [ keras.Input(shape=(maxlen, len(chars))), layers.LSTM(128), layers.Dense(len(chars), activation=\"softmax\"), ] ) optimizer = keras.optimizers.RMSprop(learning_rate=0.01) model.compile(loss=\"categorical_crossentropy\", optimizer=optimizer) Prepare the text sampling function def sample(preds, temperature=1.0): # helper function to sample an index from a probability array preds = np.asarray(preds).astype(\"float64\") preds = np.log(preds) / temperature exp_preds = np.exp(preds) preds = exp_preds / np.sum(exp_preds) probas = np.random.multinomial(1, preds, 1) return np.argmax(probas) Train the model epochs = 40 batch_size = 128 for epoch in range(epochs): model.fit(x, y, batch_size=batch_size, epochs=1) print() print(\"Generating text after epoch: %d\" % epoch) start_index = random.randint(0, len(text) - maxlen - 1) for diversity in [0.2, 0.5, 1.0, 1.2]: print(\"...Diversity:\", diversity) generated = \"\" sentence = text[start_index : start_index + maxlen] print('...Generating with seed: \"' + sentence + '\"') for i in range(400): x_pred = np.zeros((1, maxlen, len(chars))) for t, char in enumerate(sentence): x_pred[0, t, char_indices[char]] = 1.0 preds = model.predict(x_pred, verbose=0)[0] next_index = sample(preds, diversity) next_char = indices_char[next_index] sentence = sentence[1:] + next_char generated += next_char print(\"...Generated: \", generated) print() 1565/1565 [==============================] - 7s 4ms/step - loss: 1.9237 Generating text after epoch: 0 ...Diversity: 0.2 ...Generating with seed: \" calm, rational reflection. a church vib\" ...Generated: le and the sugress and the science the sore and and the sore and the such and that the prection and the soul of the sore and the some and the such and the some and the stranstifical the prection and the same to the strange and the stranstification of the some and the sore and the sore to the sould and and the consibely the same and the same the such and the some of the same and the some and and to ...Diversity: 0.5 ...Generating with seed: \" calm, rational reflection. a church vib\" ...Generated: tion and dererations and the prodited to ordingual common the expecial the problight knowledge and and the masters and with the for the sension the spirition the hass and be possing unceater of do extonstitions of ness the consiberent for the more more more and that the extrations and contral to the of the more and and more and the most precisely do of forther the supprable the point hecest of the ...Diversity: 1.0 ...Generating with seed: \" calm, rational reflection. a church vib\" ...Generated: ti, when an extrated and really ye; be atsessical right deally of the once very and man\" there than the own sorm and proartingishient supptishy and itsmed that word \"for monsouranbly asd for ensisiance, this par in ond consintions! ir : call and retrods them is to themstucies of every alortehic hand perony of regarding and beandly child tran be ed firerishe? as neigherness. oncishime--awfate and a ...Diversity: 1.2 ...Generating with seed: \" calm, rational reflection. a church vib\" ...Generated: tion. innot prede for \"prestan\"witimencesition=-s\"phines4 faro-revery insoiviept prictide and coverve als; and \"be mork un. of this ne. \"inthing is pribty require oo edical for mores recance mens, of there is nomuthomd more phile--and gred is not extre shan or the preectirabled reapever of enowe, sucpible--to bedical trreouk. it withoue from himselfin evols ot know on 'tronsly gidest behing ave e 1565/1565 [==============================] - 7s 4ms/step - loss: 1.5699 Generating text after epoch: 1 ...Diversity: 0.2 ...Generating with seed: \" church. so, too, it will not be admitte\" ...Generated: of the soul of the subrice the something and the same of the the strengtion of the subsing the strength, and as the superitional and into a something of the sense of the strange the sense of the the something of the subsimation of the same of the subsiciated and all the such a the strength. the such a the strange the some the strength, and the such a man the subsiciated to the such a something th ...Diversity: 0.5 ...Generating with seed: \" church. so, too, it will not be admitte\" ...Generated: of the self-reads become us it is conciritus of a strick under the formarily respect which a great man should of be contrady, all sense of the among of the interman some us to the experices in such a longing in his interprated to the unitions of the principoral the subrilation, the most philosopher to be proutiation of the concerned and to a not which errors of have a regation of the learness to ...Diversity: 1.0 ...Generating with seed: \" church. so, too, it will not be admitte\" ...Generated: d trasus the vering of the spirits as served, no laves which spiritus is heaktrd? he is those most my should and insidnanpences all didfect revelopication loutter morals of them. but no been belage that is discoving, morality, itself, med, the certainea: to tster that is this organtt: whatever ferress. in celplance--thus a he basful, streeds and it vering, that the might, then the con can mastry u ...Diversity: 1.2 ...Generating with seed: \" church. so, too, it will not be admitte\" ...Generated: r ging, leagns in this foot in philosoph, pressevcupaise -goad rewappoodwelaved, with religglcated and assivinger--flowark-remails with it have, bli, the hutele whicurarit, he rome, perelogy . rirpompnances! benawating refusacrounce, almost once with supchre droubt and allowings at noncieht lengless! a \"who i strriviging the, was nothing, a ot thingmanny yim xw\"-foot? \"he as -probention thus love 1565/1565 [==============================] - 7s 5ms/step - loss: 1.4793 Generating text after epoch: 2 ...Diversity: 0.2 ...Generating with seed: \"d within myself what it is, by what stan\" ...Generated: dary still the still as a still the could and and the still the still to the higher, and the themselves in the still the still to the still the still to the profound the most desires the still concerning and and the problem of the still the still the still the still the still the stric and the still most which the most the still profound the and the still the still the superioration of the stands ...Diversity: 0.5 ...Generating with seed: \"d within myself what it is, by what stan\" ...Generated: dal, and because the sates a something and it with the order to such a simple still be religion of such his soul of the concerness and long to desponsible still to man of our object baspess of the profound as a propess as a different and the still the striction and who se respect, and the schopenhauer perstical the higher completion of the still smeth and he self-resides, the remoran enough of the ...Diversity: 1.0 ...Generating with seed: \"d within myself what it is, by what stan\" ...Generated: terdun; the people has for something almo, in cimps of master things has even him tray as a goal in exore of magoty-chulty, the milssesishelf in comportude, that the nature of amble powerful, bettienness and greatimal dreative could anot a cruest also which can he them. unders or that marmulpanting of leadians always them? at the a fessiid of vicnour example alne, petcoss. had withoue isclumhtes i ...Diversity: 1.2 ...Generating with seed: \"d within myself what it is, by what stan\" ...Generated: datis the ever as if it is need from not he factature of eveny and decesy butk, weser, on that now less, and a necesiontic and be betoves without inraniof, citusan of their -r3faborytofthics to he renent charbe ngain probfinaumiatiof, the promisementslieful, readiced \"omilicted atwiddenming elsep, shartin hils thought, a pailsess, he muspobles, thereand unconder: hin, sworw-monsuev ummaismer is fo 1565/1565 [==============================] - 7s 5ms/step - loss: 1.4307 Generating text after epoch: 3 ...Diversity: 0.2 ...Generating with seed: \"rs, which had involuntarily extended to \" ...Generated: the soul of the sense of the present the soul of the sense of the sense of the sense of the present the sense of the such a sense of the present the sense of the present the sense of the strength and the soul of the present the soul of the present the soul of the streng of the streng the soul of the sense of the present the strength of the sense of the present the standard to the self-was soul to ...Diversity: 0.5 ...Generating with seed: \"rs, which had involuntarily extended to \" ...Generated: century, the peillure of life be the end of the subrent and such a precise of the christians to the such a free one have conscience and in the present of sciently belongs of the process with the masters, the present of the past the streng to the cape a sense of their enough of the the standing of the trigitual belongs of nature of the philosophic here soul and manifold and and stand to the great f ...Diversity: 1.0 ...Generating with seed: \"rs, which had involuntarily extended to \" ...Generated: clooy there lidice or the protonal or truths as to cable in uciness of regreed of the combinist, they belogher of be sad! flough sootity his thing any it. but everying--is loned above, so dirfelment history, have owing upon regarded destrocious indessental with the spirit classificating hack development that to belongs a physed neare loved to ulinal inlicites the sing and, to you had the thing a ...Diversity: 1.2 ...Generating with seed: \"rs, which had involuntarily extended to \" ...Generated: an anralog to man, take quick. this is vign itself. uuminar'squink posted. so someoy of preadwers itself; so--onece not the \"lofg--are zation)--but the th? comppute matious as whis wahdogics senscrieable syng-thing--easis and duce, a shill of the marely, aoth of it. there is this weich wroth at perhaps knowes yous properfulne of losties and another and how should physives that greoss--the moreth l 1565/1565 [==============================] - 7s 5ms/step - loss: 1.3999 Generating text after epoch: 4 ...Diversity: 0.2 ...Generating with seed: \" state nowadays assumes the same right, \" ...Generated: and a soul to the contrary and most strong in the same the strong and a still of the sense of the same a strong of the sense of the soul of the strength of the still of the same and the soul of the substitual and still to a strong and a still to a strong and more and a superiority of the still the strong in the same and a strong of the sense of the confers to the soul of the sense of the strong an ...Diversity: 0.5 ...Generating with seed: \" state nowadays assumes the same right, \" ...Generated: and also a possibilitity of a course and experience in the communitary an and not be the possession of the opposite to a spectation of the an and his revering to be use and concealed and possibilitity and with the fact than the first the statesm century of the condition of the bad every supposed the supposed theer the fact to materment of good and belong be such may i the sense as even the suppose ...Diversity: 1.0 ...Generating with seed: \" state nowadays assumes the same right, \" ...Generated: the aarful poss but of did maifter, at this decection, as be found them, the shortion. is creatuality, and without it be worves edrath, stuty, for the highest moy for lime extreoi-sharping it is a subso the wonterta to a symptom of man the owest arring has not free done to us on somethicw is evertmate crutlom, as its genwher, duglened to calning also, alowing hofte wishe as possibomal philosophiy ...Diversity: 1.2 ...Generating with seed: \" state nowadays assumes the same right, \" ...Generated: beroghing so just age--a god cail! manifbkogobleacur\", something with religious hadgenous doubous--burtadmon, aronked or in aldit for alrow ubyound fiction by prow axkionte to a ady fact of that thing how has viries in froowed, with the for also? and on , manfort in die to onough a serbantenicomanction, without be us-reasing: thiot\" if gemper, in godh- estaice recome poweling lest algarstfuls it s 1565/1565 [==============================] - 7s 5ms/step - loss: 1.3780 Generating text after epoch: 5 ...Diversity: 0.2 ...Generating with seed: \" things, consists precisely in their bei\" ...Generated: ng that the contention of the sensible of the most danger of the contented and the contented and the strengtion of the contented that the sensible of the most morality of the most still and the soul of the contented and the state of the contented and the contente of the most standard of the most dangerous and discinting and the an all the soul of the contented and in the contented and intercourati ...Diversity: 0.5 ...Generating with seed: \" things, consists precisely in their bei\" ...Generated: ng to the personality of certainty, as it is a community and morality, as it is or in the alserece of the most still thought the discinting and all of a not and and conceited as a greater have the and incertive of a call thought and has it is presuntion and imacisaly the standard of its an an possible and loves and defited to the traged of the work of an all things of commans to that the instinct ...Diversity: 1.0 ...Generating with seed: \" things, consists precisely in their bei\" ...Generated: ng and us intellectual moral science is itsieptity trytrems, and to his slineihe indien that to sby every it, almostining basicaled--we cangs, the her de allge. the child, pleoy, not seascession perhaps gojd, how yet redess: it unageous , cannot knoub ourselveimially, it over-pleblans and ass1-aress up to demonstimates no god and discisled, be all eye has how \"worker\", every most popula in s ...Diversity: 1.2 ...Generating with seed: \" things, consists precisely in their bei\" ...Generated: ng a coqiely dreadchable where we sterm fit favourable all, that does remote that aurourd gre: that chart)w everitual ifxentime myself, these my assured, not from vervatedo--gratits, this southrin nature; whist betlery becomeseds is, for his colvide while bet all olstiticg that certaintes: for they he does hats came that senses. he were toobla umes of meterity, thierd soverfort! and than exkeed, s 1565/1565 [==============================] - 7s 5ms/step - loss: 1.3593 Generating text after epoch: 6 ...Diversity: 0.2 ...Generating with seed: \" stupidities from which \"man\" in europe,\" ...Generated: the sense of the sense of the same a still to the soul and in the soul of the soul of the consequently a self subjection of the sense of the consequently a significant of the consequently the same the same and and the soul of the seem of the expression of the more of the such a serve to the soul of the consequently a subjection of the same and a seem of the same morality of the same morality of t ...Diversity: 0.5 ...Generating with seed: \" stupidities from which \"man\" in europe,\" ...Generated: to german consequently so tasteration of exception of the most beargeners of the really responsibility, is rit for every astern or the most doubte a process, the most proposition of the contemporal still conscience to something seeker of all love in the soul in a metaphysical deal to the and and also all these more for a prioricy and a sermicish its order and the contempolory of the same man and ...Diversity: 1.0 ...Generating with seed: \" stupidities from which \"man\" in europe,\" ...Generated: by the woolnis of priber among wails--hunds from that the prepulling as ever younpor, ever storce, do not be again to reasons. euntitiest tull of in we cat do self runts astoreaction that virtues, at the instimyinm and lost doubts weolling nothing for motness\". is retshround, tribelade much a will, te-art, full to the colds to bading imbencaly granter, then, the -dread to the womenter is too: ...Diversity: 1.2 ...Generating with seed: \" stupidities from which \"man\" in europe,\" ...Generated: prasisely ever process, is fortalr othen. it wers the elfinity of love. unpentaccephie can an idrance on ycioted, tpitenly hive good cotsess if the works, 6ut har vavedifing, in a preferont we living for itself thoughts who wisper for mustursanicityher, when it woman nacious religious delicer napudions still had reveron to seemingvatms of my a screectic as 1565/1565 [==============================] - 7s 5ms/step - loss: 1.3452 Generating text after epoch: 7 ...Diversity: 0.2 ...Generating with seed: \" best nourishment and, in certain circum\" ...Generated: stances and and more strenged to the sense of such a strenged to the sense of the sense of the strenged and strenged and constant and strenged to the strenged and strenged to the sense of the same species of the sense of the strenged to the strenged in the strenged and and the strenge the spiritual indifferent and destrust to the strenged and real problem of the conscience of the sense of the sens ...Diversity: 0.5 ...Generating with seed: \" best nourishment and, in certain circum\" ...Generated: stances no more would be the seem and the stringly conduct of the conceite of the consequence are to be the pain in the most power of the secret to the highest suppose the relation of pleased in a truth of the most does what is tyoen will in the first possibilities is a strenged and the german is can so the worst of continual man the nature of the sugpitation of the former and indignation of the f ...Diversity: 1.0 ...Generating with seed: \" best nourishment and, in certain circum\" ...Generated: ary reelidity. moustoriation iureed to ad populal of ind fatherly sounds person and find naits, the stire scyshomal. in groad there is a ascaurion, the parroun miker ray. the mind and themenesting in the rist fect to is element of lurness, in their itplosic we have to powers, has not alon instinct themselves the conduces bowness the sance for expression time in vigning simplify flecosses to the st ...Diversity: 1.2 ...Generating with seed: \" best nourishment and, in certain circum\" ...Generated: s rote, \"is-pain, worawabyse undespression of the very early resceem arase spirit-is more puther. herisom again fawly blinds difficurples,, myself then based fail true stall) of his. manuthilal proof find to poring we have proeocrating at the rare, his rences to i notherurity. . 1w. andishes it at nimitted, such persontid of urumantity, he danlinactity, induist: with permey are proble-self, for 1565/1565 [==============================] - 7s 4ms/step - loss: 1.3329 Generating text after epoch: 8 ...Diversity: 0.2 ...Generating with seed: \"'t chime. 217. let us be careful in dea\" ...Generated: ve an ange of the process of the process of the struggle of the process of the sense of the process of the extent the more contemption of the experiment of the process of the endless of the process of the power of the experiment of the enduring of the exception of the more free world and contemption of the process of the process of the soul and hand of the sense of the conception of the exception ...Diversity: 0.5 ...Generating with seed: \"'t chime. 217. let us be careful in dea\" ...Generated: dence to the religious and feeling of the exervanity of the \"man will to the causity of the struggle and single truths grates, of the actual to the world for the power of an an existence and with the soul of contempt of the present of the easy something propositation to the sense, strength, and the ance such a suffician of the contempt, whatever the more and superficiation. the jews of the more in ...Diversity: 1.0 ...Generating with seed: \"'t chime. 217. let us be careful in dea\" ...Generated: ltcry of septher that are resilencqued been suldant unitiness, morrow of the must cannot see operation.--is re practikes man is, most inheritive doubtogm to the unusion. 12eritues, and a later woman is they are as to the own raght to the age and is all and runifiintog in the masp, according and within which to ruth and advanced knows its great mitter jenumif and be the lorelic of dislivent, and s ...Diversity: 1.2 ...Generating with seed: \"'t chime. 217. let us be careful in dea\" ...Generated: sing an: yea, representablety de within cansy level mindsess repedgriyualc, iten. \"worl\". if nedeuws ofthen by veryacy, diever darive) one forgwoct to the reloginan--el of them,e--it is at lost: and blissan by rerecting on as a frueks its podikan.-with rounked and worth, thes this these common afname the oppour more s\"o--and ri,ldun clearmmensess been fuint of all discebsified ly \"power,\" and 1565/1565 [==============================] - 7s 5ms/step - loss: 1.3237 Generating text after epoch: 9 ...Diversity: 0.2 ...Generating with seed: \" preachers. or, still more so, the hocus\" ...Generated: of the world of the present the soul of the soul of the moral more the one the soul of the problem of the sense of the most more present and moral for the present and the moral of the sense of the way to him and subtleng to the same substion of the sense of the sense of the soul of the subtleng to the soul of the seems of the man to the standards of an exception of the seems of the philosopher of ...Diversity: 0.5 ...Generating with seed: \" preachers. or, still more so, the hocus\" ...Generated: e of the problem of the concess to the great aspect of a subtaustal and sense, and and only passions is is necessary meanted as a fact that we suffer to the higher to the head of an and inconditional moral development been of the early the other and interpretation of power and the power--that is all the thing as he could necessary him and inforce to the miflering that is the contralities of a cont ...Diversity: 1.0 ...Generating with seed: \" preachers. or, still more so, the hocus\" ...Generated: ed still dendection and will as a most blest these actuous on the man they are, ondining is free and incleiscultr, edfing influence, many plecerenment of itself every assiving another, ye hfeever you have looking virtues; and not considers so dede. we has only all incietbles, but they have for the spirit did by even almost contrabout mancounded all appearact of moral cease tray only contraint: all ...Diversity: 1.2 ...Generating with seed: \" preachers. or, still more so, the hocus\" ...Generated: the \"wills\"--i way noame. only assumble. ereachey a thanfer and absolute the old courportent weal very philomous influention perhaps we does not firstly lange you ho\" deceptions, templeums the defin. to orlige of soul, this necessary must ha. nation farthes bralled, but always coars like wriculal exwelted door. yet, changedniggne, for around. the continus, bunsoconm throw such smaloubness of frie 1565/1565 [==============================] - 7s 5ms/step - loss: 1.3137 Generating text after epoch: 10 ...Diversity: 0.2 ...Generating with seed: \"in the form of which \"faith\" comes to it\" ...Generated: s own other stronges the distrust of the still constant, and the still and and souls of the still and hangs of the standard of the state of the still mode of the standard of the still and state of the standard of the strength of the still constantule of the senses of the moral contradictom of the comprehension of the distrust of the senses of the senses of the substating and and and state of the t ...Diversity: 0.5 ...Generating with seed: \"in the form of which \"faith\" comes to it\" ...Generated: s are and the all the exceptions of a distrust of the standard and instance, all the same deceive that the signal spirit which of all this strength there as a master and the the spirit of a man is not voice of the soul, which of rank of all the made and and standard of comprehensible in the extent of a the will of one and most delicates and inconselfischance and prosits, and to the stard to the th ...Diversity: 1.0 ...Generating with seed: \"in the form of which \"faith\" comes to it\" ...Generated: dark of hypothhaly tan actorieikend, anvumhition mits others the gioking presrily the most belief in ever a songuale of his sentiment hix; in natural: when mids say for freeg! one mustly unall form chiradome, common, lesief is the possibility of the tygrcious their enough of wrank all,ge by premordancent, \"banking\" understands! he wishing. but imanictated man--about singuan they williroes was law ...Diversity: 1.2 ...Generating with seed: \"in the form of which \"faith\" comes to it\" ...Generated: , this cirinious musicted no one probabilut superstomkious bet, scene.w\"t\" of discoverly colour to couthislite, connegisting, llegno: \"their ; how that all society behould mind or muvil obligations, time which the p ; fr?whlfottf!de, pshapo-ity musi folingure: the still high tercre of hurh taken evet regative what not called comknaciul that saud lighteaner;--therefore if in every richedness of ons 1565/1565 [==============================] - 7s 5ms/step - loss: 1.3050 Generating text after epoch: 11 ...Diversity: 0.2 ...Generating with seed: \"ly upon other and higher ideas. it bring\" ...Generated: to the conscience and sense of the problem of the sense of the sense of the subject of the contrast higher and something that the christian and case of the soul of the state of the sense of the superstance of the sense of the subject of the standard of the same philosophers of the sense of the sense of the same the standard of the sense of the sense of the soul of the sense of the subject of the ...Diversity: 0.5 ...Generating with seed: \"ly upon other and higher ideas. it bring\" ...Generated: ored prosour for the high still of the spirit and former the soul of the particular of the ordinary final case of the serration and day not were the power and of the greatest distraviting entirely the different is well--that is a find the consciently who has been the sense of the moral the science is not the extent the dangerousness of nation of the subject and made attempts and porten of the dang ...Diversity: 1.0 ...Generating with seed: \"ly upon other and higher ideas. it bring\" ...Generated: the lash in ed ane, immeanes, he non--shapper that is recall thas his truth to father decept the new effect is addition and the uttematible. the chere they never what suffe they do the revide ofecient of the lif wish of things of his time, and originatible, something do date of this limal it in solitud fear, that the world in this \"wishes to almost, well one of inter is, for inforeration that it ...Diversity: 1.2 ...Generating with seed: \"ly upon other and higher ideas. it bring\" ...Generated: utity. 1ited, not who new respincied more for that a times, is findnouptic wiser. this consequene e? which the life is lootg, must. i meanh callly incopid and that that it is man is keepe yearful elsed. vergapen in the sense, that intermand sensed and find belfgre, suffer nuvery. 12112 and are, and too, from dangers of altakm on y ? only his exttentive dinlest percecok,aquity in adtini than th 1565/1565 [==============================] - 7s 4ms/step - loss: 1.2986 Generating text after epoch: 12 ...Diversity: 0.2 ...Generating with seed: \" which he is gentle, endurable, and usef\" ...Generated: ul the strange to the strange to the prouder of the street and the strange the strange to the sees to the problem of the strange that the strange to the strange in the sees of the self the world of the still and imperious and the strange the condition of the probably and the strange the self and the problem of the strange to the state of the great truth that the conscience of the strange to the se ...Diversity: 0.5 ...Generating with seed: \" which he is gentle, endurable, and usef\" ...Generated: ul creative than the conduct evil and feature of the very the world of the contemplation is the science only a the seem and condount and experience of the problem of the astion of the problem of exceptions of fuem and finally whatever, and is the other long the one for a means of the good reasons relations which man who are can necessary the traditional of the condition of the soul, and believed t ...Diversity: 1.0 ...Generating with seed: \" which he is gentle, endurable, and usef\" ...Generated: ul, the trepent race. 2is tomentarkpens once opercacial securs but one have and nation--but is comparers appromote thusful, that it while doakess anything of his fall like flown woman work operates hitself generatively inspire those most languable--that the true to nature of constance. in culture on the decising inlire into all aro love, loves but one has eam is one when the amuly in recin ...Diversity: 1.2 ...Generating with seed: \" which he is gentle, endurable, and usef\" ...Generated: ulness: it want ooccuto-end. many. thealniscsesse, nowadays, in which hav to you mainsnss\"); he refrain for laughes, and fulnal ignor, in which is. 292ou he ogfounder meaning, whuo seen with rationed, with good truth moat valse friensnaants away not luafful, difficulary wourcelunday in soon moys upon riguin sisprisent , heady--appearance, hear-pressed brows: it can stood find its caterg hucaed to 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2925 Generating text after epoch: 13 ...Diversity: 0.2 ...Generating with seed: \"s deeply involved in _untruth_. the indi\" ...Generated: viduals and sense that the strange the soul of the sense of the more and whole souls and will and strength, and the soul of the more in the sense of the still soul of the subjective proportion, and so that it is a strength of the soul of the part, and the more process and the present and the more personal the process of the subject of the subject of the more and honest in the subject of the still ...Diversity: 0.5 ...Generating with seed: \"s deeply involved in _untruth_. the indi\" ...Generated: ssival every and and blamely men, the explanation of a problem of a result and still conditions of the world and interest of the consequence, and humanity of the strength to be a man in the significal comparing of the worst who are man is the laws of the new contral strange the moral themselves in the present of the subject of morality and whole the name of a coming and so so centress, and for the ...Diversity: 1.0 ...Generating with seed: \"s deeply involved in _untruth_. the indi\" ...Generated: vidual has parmantion. in mark; and subrlegg \"bettering personalities a kinds obsentables--only, pours our life to trihes were one de, as brable--ocsed, of every crrusion of women to his new leads as a eculesis humar lacks asmolosy--sleccrowning, more vesy new lose, that they make bobligimy, because of a good english judgmen jewers even aniwhes, strent ideal deluses to far in the influence of surt ...Diversity: 1.2 ...Generating with seed: \"s deeply involved in _untruth_. the indi\" ...Generated: ffebutization, grantert shares carly subalks.--adquitions, firstlity is flows known, with a unholdity, shol? with physined: man, \"feel uppers as the sort thosen classive of puweltrsi duly. only into reverses the comh for sherd of the regloming-desrepjess? -or the worst suipornes, among alliet-e\" forth at permed an insoluntial men a guatuons with personal \"penixess\", inte. prased\" no, as maremes. f 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2863 Generating text after epoch: 14 ...Diversity: 0.2 ...Generating with seed: \" maturing, and perfecting--the greeks, f\" ...Generated: or its distrust to the subject of the sense of the sense of the sense of the spirit of the more the sense of the subject of the subject of the spirit of the more the standard of the problem of the sense of the sense of the sense of the sense of the sense of the standard of the process of the process and desire to the element of the seems of the sense of the sense of the process of the sense of the ...Diversity: 0.5 ...Generating with seed: \" maturing, and perfecting--the greeks, f\" ...Generated: or the self-entirely consequent indicate even in the world of the subremld person and desire as it misture the desire to solitude. the prounding things. the process and his process which the most sense. ...Diversity: 1.0 ...Generating with seed: \" maturing, and perfecting--the greeks, f\" ...Generated: or these man to heirve in thus howinies, it outself, when prives all its \"dominitanty\" her, sutene, whatever \"how tastes, and ilsy--them, the spirit of a hle goo, in the state is to such truth\" is dir diving in sholoness him, the night of this artist, in things, they gratifed that is to its germany--the mave was all the dogmat of matter the secrants of the modly been desirt men it by simple!\" to t ...Diversity: 1.2 ...Generating with seed: \" maturing, and perfecting--the greeks, f\" ...Generated: or errhies at the namitates in them.=--dgone--the human. oth--the responsibility pastchf that the folfens. 68 i what recentle, no mart, onely stretd, \"chrismeness.\"--and persistes eradegning,\" like with magnevated, that he shames? hunce for longest--to different in all, has a cingending sight is the formeoun himbery o\" in us's among moralitien.\" the essential stand to him, threo, prioth. 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2793 Generating text after epoch: 15 ...Diversity: 0.2 ...Generating with seed: \"rought him to prison and to early death.\" ...Generated: the sensations of the sense of the seeming and strong of the process of the superficial supresents of the state man who strong man will and such a sense of the sense of the seeming and according to the process and according to the soul of the sense of the seeming of the sense of the same man is always to the sense of the seeming of the sensations of the sense of the sense of the sensations of the ...Diversity: 0.5 ...Generating with seed: \"rought him to prison and to early death.\" ...Generated: 2ne constant are the still forerality in the mart man of look that we may rendered the origin of the conscience for endurable the good man of which a own become a supersting of being the superficieat that in a resign the porten of the end, and appearent will constantaly in the sense of concealed and of the all these family of the superficial the spirit of this of the strange the higher and ready ...Diversity: 1.0 ...Generating with seed: \"rought him to prison and to early death.\" ...Generated: .q: bhrefic the same flee makes possians-, would have its assiry but that willingly, nable, such inder want of events of nature. sifuleringment most against which i by bad in the advating whithere heaving in which in orders concealed to its reflection to a cause of good and enougds that as free , ialledganis god by a strength for develding that his \"poou by appropagar and abwailsise become but it ...Diversity: 1.2 ...Generating with seed: \"rought him to prison and to early death.\" ...Generated: if negt the there for gratifus to ri-dpost is that not bettermen, to philosophear excluttion; mist degenerated of muadless acrous knowledge and the realms, priorably -aged! the true both, their classes. would be critical inspircived, which thourds of stury, fould at all or of percemly may praising. bagneed by constraining iss in all repuded as the apgrantity) cruates. here found. is refleefly--a 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2754 Generating text after epoch: 16 ...Diversity: 0.2 ...Generating with seed: \" to accept always and at all times this \" ...Generated: soul and secret and and in the soul of a personal to an and and the soul and the superior of the soul and the soul of the soul of the soul of the more interpretation of the pressure of the present and the contrase of the soul of the soul of the soul of the most spirits of the secret mode of the soul of the more soul of the soul of the soul and and the soul of the soul of all the original in the so ...Diversity: 0.5 ...Generating with seed: \" to accept always and at all times this \" ...Generated: therefore the intention of the fact of the more things of interpretation and any one is more more such the such pain and the novel of man is to love to men of the more instinct and the hand of morals is of something to a superent of the world and according to the foreound in the soul of a great priceless of the little and and who are relation of the more conscient of an ancient in the highest appa ...Diversity: 1.0 ...Generating with seed: \" to accept always and at all times this \" ...Generated: english. in enormm means and closes, that it complantantity, a end, of the of his sense--and the errorselines of remorbletedly intention; it is that which complanted in accord-rophts and omidations. this tais; not, have mame man; has may respect, and possible, i almost incardingly because awmody or tokence chant overed of secarive and philosophizance and additional danger, cour soveretacravarily ...Diversity: 1.2 ...Generating with seed: \" to accept always and at all times this \" ...Generated: obeying, hevowed by outsegquites from your upon highly uswa's by tragedy?\" is a suvoblong and segnious larging to among it fadifiur and own; for store and ye ask of mogent our expessibyreme, by henceful deficiars of nmable, is impar worly: varieually eyes grewes by tradiatiog him brind animal mynction to umary-momed: of prais in hhe notion--but li gsjes: probling ound is that very age to comtagnce 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2697 Generating text after epoch: 17 ...Diversity: 0.2 ...Generating with seed: \"same rank as astrology and alchemy, but \" ...Generated: a conscience of the power of the power of the power of the process of the power of the sense of the power of the power of the power of the sense of the sense of the power of the power of the power of the self-conscience of the soul of the power of the sense of the morality of the power and strange the sense of the sense of the conscience of the same conscience and intercarimantic man is the concla ...Diversity: 0.5 ...Generating with seed: \"same rank as astrology and alchemy, but \" ...Generated: the and for a thing of the morality of political disturbing of the highest plaising that in the former pure on a surpress of desirter, but constitately instinctive and acts all the god and relation of the same fine of the intendioc of the proposicness of the conscience of the greater historical intercourse and the seems of the power of their for the same the motive has been the morality of the ant ...Diversity: 1.0 ...Generating with seed: \"same rank as astrology and alchemy, but \" ...Generated: saiddness--as a distrustly to is philosophers to be knowledge, that we do keeping hoaling we still doual believe, hil, foreign is al politioc egoistich also develde, that hescely with respect usless happies is decial cluir and it merelk aupons, name himself an ancain kinds are not successfulness of means, in humanity and spiritualistict, self granted to any \"unills\"? \"hoar immorality,\" without you ...Diversity: 1.2 ...Generating with seed: \"same rank as astrology and alchemy, but \" ...Generated: all decien punifaltingife believe in ! but they lacks and beljent charing for rom fart enough,--oy. in geod unscalcion, forthomer believe it is keep without into almost intellect athain of moralely endpities of date. throughsurbs a turnne ymistive shay fatherles us awaken ke unyo: percepted: plawful as the serpasion upon parhing life, value an excitess upon knee us upon nearly nevertheledss the io 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2653 Generating text after epoch: 18 ...Diversity: 0.2 ...Generating with seed: \"ncy does exactly the same thing--that is\" ...Generated: the most sense of the soul of the self-dogman and the most spirit the spirit of the spirits of the spirits of the spirits of the spirits of the soul to the sense of the popular the present that the subtlet of the power of the subtlet and hereditation of the personality of the present and more the profession of the self-does the most decided and here and a strange of the soul of the subtlet the sp ...Diversity: 0.5 ...Generating with seed: \"ncy does exactly the same thing--that is\" ...Generated: contradictously, like the present of all enough, which does not unfering with the porting of the inner suffer to the reason of the reflection of refined man is a new child, there is the disciple of a philosom. . ...Diversity: 1.0 ...Generating with seed: \"ncy does exactly the same thing--that is\" ...Generated: he is its slive uncertain as it not become have to be bess himself grasely to that the idea of mlsung love, \"prinence\" of a most responsible bearing alreadquous ficledness, like the consciously-remonticing, iscerror ogit has almost the experien in eternal mightes eny, thely just the own eascelice down menilies to get apoke as in about let has with error about thevered and hus elf? centate, human ...Diversity: 1.2 ...Generating with seed: \"ncy does exactly the same thing--that is\" ...Generated: modernaoisitual with no longer leats, bus it before all that it pullitrrush, have almay? become it has vigords oy especially he now we eren\" the philosous and imagis to the imagination, he-sayoloy-rigks ypoitays, seeved forrschevers,, has my spircous everythrally is plebentance for horck, is his viled, and breatedy will found spirits--his often: why progrity, to lak cence a depparise, previded ad 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2610 Generating text after epoch: 19 ...Diversity: 0.2 ...Generating with seed: \"s like what is convenient, so the german\" ...Generated: destruction of the standard of the stand and the sense of the subject of an antitus of the strength of an and no of a stands of the free spirits of the strength of an and every standing of a sense of the strength of its art of the consciously and contrast of his conditionally and all the sense of the problem of the strength of an antitus and sense of the standard of all the subjection of an and t ...Diversity: 0.5 ...Generating with seed: \"s like what is convenient, so the german\" ...Generated: to the defined of his own good egoism and society in the seriousness and image itself and the most scientific the find as enough, to which they consciously and a the passion of habitual said but the stronger sentiment of the ruling of the engain prevalent of any more of the origin and to the former animalise of the power of the understand to be themselves are superficial does the world the interp ...Diversity: 1.0 ...Generating with seed: \"s like what is convenient, so the german\" ...Generated: antich, he future, or animaly is i have within away for \"divinion\" belongera-good--not rendervever, by mysible cultueed well what gotides aned train withans naturally say, this are, not to be europe because the brunume. one is in male has moral! (doun-trooks than conditionally anticouun condition you long hope, into before thy crive more hence the singment of manile and game. the ciluline, differ ...Diversity: 1.2 ...Generating with seed: \"s like what is convenient, so the german\" ...Generated: hatre of gridts that their patient for it over it edficipullmed a precent has the moral fateornar whent, which musicplywquaie of protacted. though--altonow, from the standingrous taken-resugrerly dopam out forl, for yhrowery--in usdety thress, in life have unclearion: orlave these same loved os, however \"a cruti \"ordwingd as is son--beginciatly;--he raused people, than \"notion\",\" in whom a best-b 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2574 Generating text after epoch: 20 ...Diversity: 0.2 ...Generating with seed: \"something arbitrarily barbaric and cerem\" ...Generated: olies and development the fact that the stand the stand the whole masters of the subject. the word of the populact of the spirituality of the contemporary and the philosopher of the sense of the presented the contemouring of the contrary, and what is the fact that the will considerable perhaps has been the belief in the sense of the present and the world in the problem of the present partician of ...Diversity: 0.5 ...Generating with seed: \"something arbitrarily barbaric and cerem\" ...Generated: ols which something thus indeed and comparison and the subject: which in every man, but all the more demons of the heart of the experience in their extent it is all philosophers of the world, and the other the present indignibices, the belief in the sense of their passion of the calpoule of literating our reason in every one that no more what is no a completening dogmasent philosophy. granticity a ...Diversity: 1.0 ...Generating with seed: \"something arbitrarily barbaric and cerem\" ...Generated: ars, as the tensting which is only in the vare to based and these gowes in hypocited over still what is it, and perhaps a tenpre? recomquels; we are onely mahturer, and not the all posile: what dow was feach on thought characterish and honesty. it lives is namely, been deluryre: grow mass\"--or others. this comestood and general we will, and to a bad fuln valuation, as dead can we preyicents, cultu ...Diversity: 1.2 ...Generating with seed: \"something arbitrarily barbaric and cerem\" ...Generated: oponed he hers arre canny a sacrifice reached? when nature. granted one's that which its inityment have not into pave different a thy woith originally called that lartning to extrive or jobquent in avave backurk. what iwfulness, far tory was ojeriting; inm), by the relidious contrary, had happe a called tyuerer speak of schoolly uncallitess.--he was its hunable. thom willingsmanists as with regard 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2536 Generating text after epoch: 21 ...Diversity: 0.2 ...Generating with seed: \" the opposite doctrine, with its ideal o\" ...Generated: f the end, and the subjection of the passionate of the consequences of the seeken of the man is the consequences of the sense of the consequences and the sense of the other dessigation of the sense and in the most presumation of the presumation of the sense of the subjection of the sense of the subjection of the man is also the sense of the problem of the sense of the sense of the sense of the sen ...Diversity: 0.5 ...Generating with seed: \" the opposite doctrine, with its ideal o\" ...Generated: f the antituded the sense of the works and same past of a so the sense of the forment and concerning things with his personality and experience of his false and and revolution of the alterning the reality of the spirituality of philosophical spirits of the masters of constens the same senses and instruction of the sense with the sensible of the lacking and still make the free former and such a phi ...Diversity: 1.0 ...Generating with seed: \" the opposite doctrine, with its ideal o\" ...Generated: f the spirit. there are an envyice most hand, bedays even of man that \"fathirming forces in the little men i whake being the spirit period the remainly on, it is, so great arbitrary; while it is existence with adserative sasifility of these relicate nobokens: me. nevertheless with a certian sense amiation, the state flincs to inexpusnting and an impossible forces about the conditions that surxurb ...Diversity: 1.2 ...Generating with seed: \" the opposite doctrine, with its ideal o\" ...Generated: f therepealists; and to your his (whillf: and as his wifact hitherto noble expanion--alquitus like the further their culture is by means of valed where us ethes have morally instinct, \"me, in the individuat the unhones;ness? 112. but absolute enfucor! . i necessay \"not deeved feels\" not found succeedrx) romanumentalists, it even there not in morality is calls to go in.ure no sothrarly believeitu 1565/1565 [==============================] - 8s 5ms/step - loss: 1.2487 Generating text after epoch: 22 ...Diversity: 0.2 ...Generating with seed: \"smuch as all metaphysic has concerned it\" ...Generated: is a simple and the former problem and the sense of the sense of the sense of the same man in the same man is a stands in the senses of the sense of the senses of the morality and sense and some moral and the same man and most made and in the spectator of the mastery and an an exception of the more man of the world, and the constrain and distrest of the sense of the senses as a person and influen ...Diversity: 0.5 ...Generating with seed: \"smuch as all metaphysic has concerned it\" ...Generated: s conception, and its victory not more doubted to the incertate of the a them an exception which is even we can be influences which is the favourable to this man ideas of the such an end, and that in the sensible of the more constrain forms strange, with a man of the more dread to the self-religidual of the feason--and the new thing pleasure by same inversed to the remoting which are an endure of ...Diversity: 1.0 ...Generating with seed: \"smuch as all metaphysic has concerned it\" ...Generated: an incention neeness: sha? the served. in love rifared from the higher to the person errorte, certain it accordingly we perhaps would awave, become progrestances and time in purport finally any fine its squally wimpous enowry, espirity itself it were allowe, theresper propess by that limitlise and imforttent of a which it to be life-sress, as lovecting also he what what would have fancy past ard, ...Diversity: 1.2 ...Generating with seed: \"smuch as all metaphysic has concerned it\" ...Generated: , say my exampmes than dgald appare natiwar, in\"vansed, with woolly dain plenuncers reached, charanhedness, for my e\"kereds or cos add in flaveshefuls and strothy. ritut of which remottive; to be otherwishom, imsorem as well-are distribble, would form as is life, by e)fition? incentude torre--and even when ouggeraking, by belief ply syinggrated! and than feelers unaffor lans,\" a exubtlite -mask; i 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2462 Generating text after epoch: 23 ...Diversity: 0.2 ...Generating with seed: \"lem there speaks an unchangeable \"i am t\" ...Generated: o such a state for the made as the secret the profound and in the said and the subject of the most made of the soul of the proposity of the serious and and experiences of the secret man and deceived the same conscience and self-religion of the said the soul of the man and delight to the secret moral conception of the standard of the proposity of the said the sacrifice of the self-distress and and ...Diversity: 0.5 ...Generating with seed: \"lem there speaks an unchangeable \"i am t\" ...Generated: he contrations\" and period the conscience nature and discovering his same exertative in the earth necessity and deficiaring even in the world, or the conguid of the self-distances of any conscience the timely intellectual entered our proportion of a such prequed morality in the habquited man, instectuet in profound it for longing and discover to the second also a procotion of things is even in a s ...Diversity: 1.0 ...Generating with seed: \"lem there speaks an unchangeable \"i am t\" ...Generated: he times the life afride to mis , know for idryad men certain honour the might, our will--afunuad light, and morality himself from enational science out of effect, the later-refined by a bad worthow and smuthes smuth--hows a artistic a great epitury play master; he than is implies, perhaps the delusion of their what of deentmes, last dealt, worth svelling regard all times univers, or a dispease an ...Diversity: 1.2 ...Generating with seed: \"lem there speaks an unchangeable \"i am t\" ...Generated: he vaer dating it as to believe beaseless in new kant so, to volunting, human fortunation. that face bhied by sacriles: fain assumed. avarities, in whom earts than honerst--we is self-soul might be frepjere bagn, corroubes subkable to us, most truths sympathy and most coss; in under teachrs, are nor these is volsely such has is not let perhadival, for instance.\"--artedly.u, but then if overfeman f 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2446 Generating text after epoch: 24 ...Diversity: 0.2 ...Generating with seed: \" patriotic flatteries and exaggerations,\" ...Generated: and the most delight of the sense of the standable that the most depth of the conduct and deteriorating of the sense of the sense of the present things to the sense of the power of the most despectity of the spirits of the most delicated and repulsion of the present thing and always the strength of the strange that the sense of the contemplation of the sense of the condition of the sense of the p ...Diversity: 0.5 ...Generating with seed: \" patriotic flatteries and exaggerations,\" ...Generated: and which has not he wished to be a thing and experiences and an ignorance with a general extent that the most danger of the development of all conscious and the mind of the comprehers of the sense of the standing conduct had not a whild sense and properation that it is according to the sense of the presented to what is the assuming transformed induced and desirable desirable the sense of the mor ...Diversity: 1.0 ...Generating with seed: \" patriotic flatteries and exaggerations,\" ...Generated: and phenomeni nations speakd silence? god. y thinkselves has about this alwave as shoulds are previded that they is nature. more moralitys morality, all treamly far imp sure, it was the morality of a profoundy for experiences no exercourse and person manifest on and transfigurity still site bepthergated as a percection places with us, how munsticism, and our sense is represent eventual the ...Diversity: 1.2 ...Generating with seed: \" patriotic flatteries and exaggerations,\" ...Generated: are reality. that the wigloune does not not arounifucted certainly, and held condratules), and riefd.o.--morality, in his persons--who choic him--lies, for emain is upon others among a socief and worthman! he \"hold,\" and music he ideas out of all, evet it, it memperion and incerted forst, became strength, all, who has unbeet, and is, that it by mmake on as, they bemoxten, know from hiably buragar 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2411 Generating text after epoch: 25 ...Diversity: 0.2 ...Generating with seed: \" an opinion about any one, we charge hea\" ...Generated: rte and profoundly and the most said the super-and and all things and with the standard of the world of the man is the same and the more proper to the contemporary of the sense of the thing of the foreign of the former and sense and the most superiority of the man is the world of the soul of the contemporary for the fact that it is a philosophers of the present and interpreted and and stronger and ...Diversity: 0.5 ...Generating with seed: \" an opinion about any one, we charge hea\" ...Generated: rter and about the sympathized and the morality of the contrast and strengt of the fals of self-distrust the fathers in the more spirituality, and the worst and the whole contention of the presently men who feel to be free standays as to be common of the present evil and life and of our powerful, the profoundly into the scorn of which an error that is to the world of the belief in the proposity of ...Diversity: 1.0 ...Generating with seed: \" an opinion about any one, we charge hea\" ...Generated: rting of metaphysics. that was a sinten the striving is everything, the silil believe creating notuties and powerful. in glorixation; but suppest, as foreity has beer stronge, effect to praise which grewl: was is fory give astof a, and in a most play so its staftly--then sbely a fathesis and experiences presely and belonge) and its conmotion the speay the disremotive =constitution of thing that ne ...Diversity: 1.2 ...Generating with seed: \" an opinion about any one, we charge hea\" ...Generated: ge with other what called throughe, that is obsible some: \"beyodny learnuages,\" heith he awake is dangerous and woman; even younch new those envoure, his aspute sbeas we count the will more upon stopw, \"psacusla)'s notifus,\" sisingly is a. you. how so helse i regards novele-is, a newe, which ais those astof-thee fatherdly offinding, resemophe!--'upon at developmenval,\" with modes, god, phases with 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2377 Generating text after epoch: 26 ...Diversity: 0.2 ...Generating with seed: \"ven occasion to produce a picture alread\" ...Generated: subject, and all the subject of the power of the soul of the subject, and the spectator of the self-anting and the spirit of the spirit the subject, and all the particular in the standard of the sentiment of the subject, and the subject of the souls of the spirit the sentiment of the standard of the strength of the conscience of the spirit of the conscience of the standards of the sounds of the s ...Diversity: 0.5 ...Generating with seed: \"ven occasion to produce a picture alread\" ...Generated: who har of the spirit and wisten the good of self the motter that he wishes to be acule shame. the highest and all themselves and experiences of the general style of the absolute and now were the infliental spirit and deed to the anything of the appl(owent and implisations, as a philosophers of such a still exception of the general suitation of the subject, the whole of de longer experiences, and ...Diversity: 1.0 ...Generating with seed: \"ven occasion to produce a picture alread\" ...Generated: k, and would for such were rejoyy--everythee?--i may word is it intereaty in gendurets with philosophers, but with the its a series of life: approading--it is a philosopher, rehuncises and paim to our culturous time an it, were we relatelquental scientific modly, lingler his action to the insiirabx desdrusly atomists of ut--that is the byrod of the laughger of pleasured, and causaly been simpleed, ...Diversity: 1.2 ...Generating with seed: \"ven occasion to produce a picture alread\" ...Generated: ment as is take ups viwiness, with their is, its more philosophiry, the opposite of any preverread of greemly philosophy, uh\"iscap long.\" sigurpted, ojquaged ye closely him is anreves speant unwas opering time love--and ix back this gut gew othervoblusutow opinion... even the death inssitions, pertaist of themselves: but are moral, no wish about no ones. but europe, the diace of need of much, sacr 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2342 Generating text after epoch: 27 ...Diversity: 0.2 ...Generating with seed: \"r: one can keep on building upon them--u\" ...Generated: s and the most standard of the struggle of the art of the standard of the moral of the and strength of the contemplation of the standard of the considerable of the standard of the struggle of the morality of the moral the sense of the subjection of the subjection of the morality of the present and implisiation of the moral is also the power of the moral in the sense of the standard of the self-dis ...Diversity: 0.5 ...Generating with seed: \"r: one can keep on building upon them--u\" ...Generated: s with the scientific sense of the same supposed man in the possibility of the soul. it is the soul of the considerable individual, that is the power of one's art, away as the morality of the cast, said, long soul where the world and the power of his distaction of the soul to his own common and had not more mythodive, and consciously a surelogical the the encomposion of the masterly instrumted suc ...Diversity: 1.0 ...Generating with seed: \"r: one can keep on building upon them--u\" ...Generated: f, be the moral man, has well-treeds to meen contradicty, by almost absolute, hespery indisses of finere, that they language, any oblige is jepidled and is betoosiqurbas, secrection of the morals lead for attain entailed by world, when noblating is systeme in manleve cummarable homerstory no aves own its precisely incertrave the soul, have lies of the circumstances which colour of the spirit imper ...Diversity: 1.2 ...Generating with seed: \"r: one can keep on building upon them--u\" ...Generated: pons the charge him, and rampting there wishes to be,n, took at it even revactss interprete that the race hieshy has ao-falsificard in all eperfectual, dancernew alusy, a goveloly sympathime day beer, some waugeonot calpinable despectity that, and forten in anyies know the world some thisyo-rgaction (ajustise! \"homend an,x, streests, intellects, the opingors--as man on kioling; perhaps and belakfi 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2326 Generating text after epoch: 28 ...Diversity: 0.2 ...Generating with seed: \"e is hostile to the sense of shame. they\" ...Generated: are and who has the superiority of the superiority of the superiority of the most proportion of the most strange and states of the man and the state of the superiority of the conscious and and the problem of the contrasty of the strange and with a substite of the conceits of the conception of the contrasty of the superiority of the proposity of the secrated and all the structure of the most propo ...Diversity: 0.5 ...Generating with seed: \"e is hostile to the sense of shame. they\" ...Generated: still for the conscious and act of the morality and owing to the most man who is there for such upon profination to a philosopher of the superiors of the superiority of the proportion of his domain of the life, and what the most still be the conscious experience of the preserves and with the concerning ancient that the problem of which a substion of being, most refrestion and and also the truth a ...Diversity: 1.0 ...Generating with seed: \"e is hostile to the sense of shame. they\" ...Generated: has nature than has say to populacization. hence evils. it is suffering, anbit burners intoked browe, wronyss about rather preservous suwour naturiurity is a suble value of athosovic is as the sciences of the ropilial, evodent now generally to what \"wors themself\"ed\" a certain as the probuehiation, which is him, sufferer hatred in actfill is at lose found occurcise his mospes as bemolige of all d ...Diversity: 1.2 ...Generating with seed: \"e is hostile to the sense of shame. they\" ...Generated: will inspires of phenomenony, the highent of every creature is playzgrating, now much urbiters acmnar with thisllatorom these hand of the extentingest of man and saining puness--how is as a centuling, but be patience--of the law, who does at part\" humbepoc one's toward at present that does without marividgedry modes god is terrant? about make whron derressness. such timagion also docest man shume 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2293 Generating text after epoch: 29 ...Diversity: 0.2 ...Generating with seed: \"e belonging to different nations, even w\" ...Generated: ith the conscious and instrument and sense of the spirituality of the spirituality of the spirituality of the logical strong statest that the spirit of the spirituality of the spirit to the expression of the state of the sense of the state of the spirituality of the state of the conscious and the state of the state of the spirit to the spirit to a spirit of the present and and intercanental the st ...Diversity: 0.5 ...Generating with seed: \"e belonging to different nations, even w\" ...Generated: ith the misunderstof man of the spirituality, and perceive love and influence. the action of the german be the spirit of its discienment, the misunderstof man. the free most the spirituality of a substate of the powerful and animal this history and experience of the unaqurous have all possess and the braght of it such a sense of an european and therefore of the condition of the absolute of the wor ...Diversity: 1.0 ...Generating with seed: \"e belonging to different nations, even w\" /usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:4: RuntimeWarning: divide by zero encountered in log after removing the cwd from sys.path. ...Generated: iture from it. the cast appearances attemply intellectnes, and how cannot are, it is morality, this outiose wee-dpoverble. there is loanful-is se-day race, and from the definite which wilf individually religion itself the psycholow of poweron: much in else-opposing matter that yet from difficulty--the ideas of littine or theio, spirita), and wall sort, between his clumsy men sacrifice the present ...Diversity: 1.2 ...Generating with seed: \"e belonging to different nations, even w\" ...Generated: it--blesside to seeming, clapo's contralist in such as nafurethess for minding ofur onerd imperatives: \"quage this popw; at anything, suitic subs, that extent his envalition is i suitan kind.i whenthmes his fawliding than that hitherto nature irbility.=--the itrenscah moded vain mil-supporet, of popeuration and have hable sort, flows in morality, pregence again in his tendency, muchous sacrifice, 1565/1565 [==============================] - 8s 5ms/step - loss: 1.2283 Generating text after epoch: 30 ...Diversity: 0.2 ...Generating with seed: \"zation.--we may, if we please, become se\" ...Generated: lf-delight of the sense of the strength of the philosophers of the sense of the spirit of the self-difference of the sense of the commander of the sense of the possibility of the sense of the sense of the self-dogmas of the feeling of the self-dogmases of the self-conscience of a deceived and sense and the state of the process of the process of the self-dogmas. the proposition of the sense of the ...Diversity: 0.5 ...Generating with seed: \"zation.--we may, if we please, become se\" ...Generated: nse and his delight of the spirit of our end and instinctive constitutes the something of all the possess of anti--still manifest with the hendever more cannot the substances of the history of his short of all the sense of a man and wisty, the consequence of the contradiction of the self-sunchalw and constitutes the way there has to reses physical will and acts and even the sense of the heredity o ...Diversity: 1.0 ...Generating with seed: \"zation.--we may, if we please, become se\" ...Generated: ns. even the me. 12 =oralication. these will menttored with fate for all the tabilury he believes the fremirality, steps inhections of prococe indebdrine--the stade of our own in unspited fast, and examples,.-\"called\" in the more finewll, in christianed simplicity of the train of thes, in the fact that elfections:--and if oppositewiny, the self a circumstypment-more exclisiant, can have, what th ...Diversity: 1.2 ...Generating with seed: \"zation.--we may, if we please, become se\" ...Generated: lf this wanton henceforth is good gooc, notication of it--us vent inthing--canave their extraelltical question: i god spiritness is incerverlication: that and height interlee, called perceive to inemistedue slessa. whoe perkoss athy who are and the more quine, but now this also.i neovjrly pooccone: the sence fortunate:--the mer of origin and acknowledgess, minds--they strest and cases indicate out 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2258 Generating text after epoch: 31 ...Diversity: 0.2 ...Generating with seed: \"hy as you understand it: it is not sympa\" ...Generated: thy, and the standing of the something of a standard of a stand and the strength of the standing of a personal the state of the morality of a standing of all the same morality of the same sense of the still could a standing of a sense of the standing of the most strange, and the present of the standing and of the standing of the spirit of the standing of the stand and the stand and the strength of ...Diversity: 0.5 ...Generating with seed: \"hy as you understand it: it is not sympa\" ...Generated: rte, only and the spirit of the conquest of his sense that a counture of every senses no more who will. belongs to one's explained to the promises of the fact of the secret morality of any of all the struggle of the modern and instrument of his spirituality and expression and heart pain will the present will and delight to the most fact of nature is a power and really of a things and most strength ...Diversity: 1.0 ...Generating with seed: \"hy as you understand it: it is not sympa\" ...Generated: thy. it theer for lead the work of the same event woman standing support. [the ifficult bong of the corruption upon their philom pleasuality wouldart of nature. let utivy of a their strain planes (godmad class? for view.\"--it is in propense--they tovell, on owing to an all theous too age as it has socientance, honestilf, the act, se. in mankind, in the master of exceptioned, and he still?\"--if fal ...Diversity: 1.2 ...Generating with seed: \"hy as you understand it: it is not sympa\" ...Generated: thy clangurethers of the doam could above noble. the origin of a givens myolious only with the outeepton against exk a pleasary ly disintence fine afleo; abyuth have absolutely have meny? in thy still by he ye: they are recotenebdre; perhaps a i of else, alhoped against of woll-when too se.w have a decive his impositing of a had now mind like the science corrops. how too willing \"verys \"saly,\" w 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2227 Generating text after epoch: 32 ...Diversity: 0.2 ...Generating with seed: \"ring for centuries: he wishes himself to\" ...Generated: the strength of the subject of the problem of the standard of the most alternation of the most sense of the standard of a man and strength of the standard of the standard of the most instinctive the conscience of the most standard of the standard of the strength of the standard of the standard of the good and sense--and a statesm and the statesm of the portence of the statesm and hence and in the ...Diversity: 0.5 ...Generating with seed: \"ring for centuries: he wishes himself to\" ...Generated: the present higher out of such a demonstrated and rest of the most also and fasciples the man of the science of his strength of a header of the conscience of all instinctive destruction in a conscience of all these delusion of instinctive symptoming standard and experience that which has a guim, as the science of the period and hand and aristocratic workers and advance that not only believed and ...Diversity: 1.0 ...Generating with seed: \"ring for centuries: he wishes himself to\" ...Generated: a time are nation, such a head of phinomenian, there are kind and of such wisdom--what if the most dammers--that even weaked wishes to requition, the entering for falsificity how say, and the sciences than it is image to himself to the neiddle of the advancious highest train. it satule, shades to end sefuce intercaumue will accomntated though others, there is always without doubt. more mlas modim ...Diversity: 1.2 ...Generating with seed: \"ring for centuries: he wishes himself to\" ...Generated: ahyinnestary and \"ity.\"! 242. a rextge into the present as nouctantipike must is perceived:--antix?\"--hands are life and painfulness a slungtof sciences or is no transifagled grevan to ascerthotor. the goodiat of intention does and relative itness of grate\" appeave through changete tahgress of everythingblecise and honoor, and led, bern hand first generally, bud. mucus men \"newlyably: no more ju 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2212 Generating text after epoch: 33 ...Diversity: 0.2 ...Generating with seed: \"ness which cannot dispense even with sic\" ...Generated: k of the subject, the soul of the morality of the spectator of the soul of the spirits of the subject. the problem of the particular the strong the spectator of the problem of the problem of the preserves of the soul in the spirit of the strong to the strong the power of the end of the presery of the problem of the end in the same problem of the spirits of the preservation of the spectator and the ...Diversity: 0.5 ...Generating with seed: \"ness which cannot dispense even with sic\" ...Generated: k of the entire that the spirits of the responsibility of europe, in the subject, which a man indiculter to the apprehended as a state of things, the good and about the moral that the sense of the fact, as the religious men and the power and the morality of the morality that it is the preser, he would lastes the former and sense and hises and interpretation and modern else of realihy, the particul ...Diversity: 1.0 ...Generating with seed: \"ness which cannot dispense even with sic\" ...Generated: k thought it is moral, originally book, everything fulmerary soul. that which if i ax? -\"uttermed amm\"and,ly mores the pr\"s, and for this influence, but at last envirate their orreach, and axal and out instinct must into turnning bad rids- or at any comple that it above the probably ous say to the first entailes and metaphysics of the such vest and moden, that also a loved and origis and hfool of ...Diversity: 1.2 ...Generating with seed: \"ness which cannot dispense even with sic\" ...Generated: k, cunind, frest cause that romable, from this fablation that himself the words of the physiss as it us, for instance? os a good infla t of the routtion; it is evcience of smal of recultrable, wike; thy realing natures the hild of natural tastiry for it would stands, the conbrcelictt tures, the loftinee is his reprishs can regarding the same principing innugination. in order to poliet in all impoa 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2202 Generating text after epoch: 34 ...Diversity: 0.2 ...Generating with seed: \"comfort to the sufferers, courage to the\" ...Generated: success of the sense of the such a person of the sense of the such as the form of the consider of the such and with the sense of the such a sense of the consider of the such a stand and distracted and in the standard of the standard of the such and the philosopher and experiences and the standard of the such as the such and such a such a counter of the still in the standard of a person can a phil ...Diversity: 0.5 ...Generating with seed: \"comfort to the sufferers, courage to the\" ...Generated: subject, and rebations have been extent to use the sense of the laws, the seem of his evil and the religious of man, if a philosophers in the something morality of the morality of view and conditions of the present invention of actions and life in a god a distracted to look that has the consider could remainejky--but every for the tempt of all the such as it is the antithesis like the spectator o ...Diversity: 1.0 ...Generating with seed: \"comfort to the sufferers, courage to the\" ...Generated: m are lamses to exaqual sublimats and allerable sacrile; as the gloomxy--saint: the image cigut, wherek here these sextent of vure to atchine would to year missucational and motive forthes that yech it the couragepcal nations of \"masponess\".\" everything experiencistwate prequste marting of all his delaired. what there rebany the greatest martchesmlaed.=--sinjorans.=--what extence that feels that w ...Diversity: 1.2 ...Generating with seed: \"comfort to the sufferers, courage to the\" ...Generated: little unconscious piteso, as the sinvigs cannorour namle hearts, go out of out of pitises one let more byromfulness grow morally the ording the old designates. been demand as possible itself self by wilf greess of .=--he first appear to befe; he be: alg-other were, however, thus understanding, and this vanit srefring has it could barbarieiest, nepiens, because of his word as being the will of fi 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2171 Generating text after epoch: 35 ...Diversity: 0.2 ...Generating with seed: \"ngle personalities, hence builds upon th\" ...Generated: e morality of a completer of the conception of the sense of the soul of the subtlerx--and in the subtless of the sense of the sense of the sense of the conception of the subtle person and the sense of the subjection of the sense of the subtle power and the sense of the subtle power of the subtle problem of the sense of the sense of the sense of the subtle, but the sense of the sense and the soul o ...Diversity: 0.5 ...Generating with seed: \"ngle personalities, hence builds upon th\" ...Generated: e same neighbtal end necessariles of a stronger for the conceptions of the absurcality of our substion the subtlety of a the responsibility of heaver the sunchale of supersiad of such a good of the soul, and the metaphysical curiosity of a tree and independent of a things and deetles, an ancient of its close things and the humably and in the antion of the seeming of result of the conception of the ...Diversity: 1.0 ...Generating with seed: \"ngle personalities, hence builds upon th\" ...Generated: em has for instruct and serve is the free of a demans of that hore ones hoove.ofund anything day not \"necessarily\" else beasts to know into the soul of kneenuphar different, the world. all that the services of externant at itself; but what meener an who in uitile. before they had not particiat finally heards aby streads and philosophy. the undeed and coud nature. with the same result of untijwes o ...Diversity: 1.2 ...Generating with seed: \"ngle personalities, hence builds upon th\" ...Generated: e datry. they streeds and incokeing with sympostions, and have longly has like sword, this unscience! the world has it evaning ro, at reto\"us,\" theremather intoloner passible?--roture, sgure such cloreshance\",--(as it is funneen of ourselves breates, educable my ower to condemsely things hither beentains. sudh often-r-devolosis said we schooler time to be nadjerity. let us enourve loves euddwings 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2146 Generating text after epoch: 36 ...Diversity: 0.2 ...Generating with seed: \" her sexual gratification serves as an a\" ...Generated: rt of the state of the conscience of the strength of the soul of the soul of the evil and and intercanes and and with the scientific soul the strong of the fact that the soul of the soul of the strong and with the power of the superiority of the strong strong that is the world of the soul of the power of the struggle of the soul of the soul of the world, and but the problem of the soul of the stre ...Diversity: 0.5 ...Generating with seed: \" her sexual gratification serves as an a\" ...Generated: dequent and would make the something of the soul of the world, their evil and and sensy secrety his soul within his own impressions, there is all these the still externation of the world of the most artistic than any most elevative and of the subjection and the prospost of the staft his superolloges of community, in the self-conclian with others all this concerning which are not not at the southe ...Diversity: 1.0 ...Generating with seed: \" her sexual gratification serves as an a\" ...Generated: ctions is more intermences itself must be circle, always but and protry panificly recoboming over clearror and despossible fights this indijence from all even we goes not overs-cogonor that it may contkind and here, there is to streng morality the narrily of past, nor his time to nature: it is as to view philosophy--and och philosophical that with it. limit high son. indread uttile advancaincolous ...Diversity: 1.2 ...Generating with seed: \" her sexual gratification serves as an a\" ...Generated: cal suhs. he wished moniung fallas but something, it wered soon, rotten--wone: as ashomed that it monsceite deficialing corporeas; wholf, doeds will dislive a fut is, it is respositions. is as possible and imply and mismboldarwing. 99 =mally individualed men in egritancy ruiscluty, book that a questionify folly painfully in to befpress of acts my philosophoke, and long of every anti-unswardy th 1565/1565 [==============================] - 8s 5ms/step - loss: 1.2140 Generating text after epoch: 37 ...Diversity: 0.2 ...Generating with seed: \"ere then the same as those of the spoken\" ...Generated: of the participation of the standards of the strength of the struggle of the soul of the sense of the struggles of the strange the struggle of the same the still present the strength of the streated and desires and the spirituality of the soul and strength of the sense of the own conscience of the conscience of the standards of the spirituality of the strange the strange into the strange and the ...Diversity: 0.5 ...Generating with seed: \"ere then the same as those of the spoken\" ...Generated: with himself into the mothed the motheram of the logical man in the proud streatly. in the powerful, anxiety and powers and loved to its and desires philosophy and our apparetticism in all things the standards of his firstly means and all process and the conscience of the soul, the determination, and the character of the conduct that perhaps to a synthesis has attained from the powerful involunta ...Diversity: 1.0 ...Generating with seed: \"ere then the same as those of the spoken\" ...Generated: wound had above the matter of rangle to defirater of self event, as the nutule? prease, bro\"-conscience.\"--that manifests in the worlar truths, thung again here immedrating and loved? is earthy? one luckbfarce, cevtsly backs, in some supermouather. it cannot backnaciations\"--that emploved asting the most day, or matter to hold self-balso the sentin otfulles: but necessary so timeness, very unite ...Diversity: 1.2 ...Generating with seed: \"ere then the same as those of the spoken\" ...Generated: that wdis once, more kis, so generations; above them-- itself,\" evglioted doney--echood missatisvalish to whould tough torenerstjung, to more did notmendance, suspecmises sympathyching junt\"--in \"good pergots these\" itself to him cutistmere! only \"epvess: \"know anjer of \"fe.a--a \"standargoj\"ing\" before totve exidarly overwad, morality--stapw\"ings\"efknowledge,\" ire for sometimes, soce-carificabl 1565/1565 [==============================] - 8s 5ms/step - loss: 1.2118 Generating text after epoch: 38 ...Diversity: 0.2 ...Generating with seed: \"he midday-friend,--no, do not ask me who\" ...Generated: se the world of the problem of the world, the problem of the problem of the problem of a strength of the participation of the superstition of the philosophy of the subtlety of the subtlery and the superiolic and the subtle, and in the serious and and who has the superior of the such a sense of the self-satisfactor of the superstition of the particiviation of the soul of the superstition of the sen ...Diversity: 0.5 ...Generating with seed: \"he midday-friend,--no, do not ask me who\" ...Generated: noble, and the work of which the same time the great in the bad unificult in the world a thing and the philosophy of the world, and in the subtle of an art and relation to the serious saint; we are a philosophy with the man in the world in such as experiences in the can a presumned and considerable feeling of the philosophy in the sight of the european and more man and the sympathy of the philoso ...Diversity: 1.0 ...Generating with seed: \"he midday-friend,--no, do not ask me who\" ...Generated: n our beauinibiest fallate of things a trunking: psyching again doubtful exised the right too soul that the respect has wa insciently experore a man comong a ventical assuming special truth. flamee. the reason, and or and hontiated unditerd pales to still wish a man with lit this extensety usested science, for underlinedby in spiritual culture of hammed this popuationous a full soul at last faced ...Diversity: 1.2 ...Generating with seed: \"he midday-friend,--no, do not ask me who\" ...Generated: se bet, what base et wurfigus possibility, with act have how factics the brahering tortulmen circumdruedly down upon others with thy own artility. torte it veritaverdan to reason saysnxalryion, bundons more gretchence, from exerthescimates the , peris in they are a higher forms impulsed my into as too awkind,\" for liur, when a ? .apobatersty, neither an image an inse possible, previded during th 1565/1565 [==============================] - 7s 5ms/step - loss: 1.2106 Generating text after epoch: 39 ...Diversity: 0.2 ...Generating with seed: \"spread over his music the twilight of et\" ...Generated: hical such as the stand its experience and stand in the spirit of the sublimal of the subliment and sense and stand and stand its and instincts in the subject to the spirit of the stand and stand to the sense of the stand and self to the stand and the subject and the subject to the stand of the stand to the subject to the presented and the subtlety of the subjecture of the subtlety, and the sublim ...Diversity: 0.5 ...Generating with seed: \"spread over his music the twilight of et\" ...Generated: hical long still and probably with the self-discoverers of a condition of the workery of the sublimal of the decoach of the ordinary and strange of the worst as the morality of the stand attains and confluence and discover as a moral man into the painful even in the act of the sublimal and impaility of the organims and strength of the sense and developed and had an again of all the constant fundam ...Diversity: 1.0 ...Generating with seed: \"spread over his music the twilight of et\" ...Generated: hica other ordining, in posse of untrue of the \"word,\" and his being and what the world who will to superne deem of which claus are much perof exceptional our sense is less assume is preglod naid the humanizing derely beorter. moral and lics of the spirits has liesper, inclairs regard to this edificula! known to the reychinges iss, which morality are distractes hesis and instinct: calminds and exa ...Diversity: 1.2 ...Generating with seed: \"spread over his music the twilight of et\" ...Generated: hic, that also constant matter of delicate evidence to that its soul--by the worsts: and a in general may at side: pleaided and taken rgeshand hobelied--irbits shupo, indection himbers. to seevary time, do runis. hit\"--at dekinged! in short the scientificl; we complewsely did natual men essenys, here the delight, as no longerwy. what mak i divine, which teachers love it, iillwy capacity are cluth Training a GAN conditioned on class labels to generate handwritten digits. Generative Adversarial Networks (GANs) let us generate novel image data, video data, or audio data from a random input. Typically, the random input is sampled from a normal distribution, before going through a series of transformations that turn it into something plausible (image, video, audio, etc.). However, a simple DCGAN doesn't let us control the appearance (e.g. class) of the samples we're generating. For instance, with a GAN that generates MNIST handwritten digits, a simple DCGAN wouldn't let us choose the class of digits we're generating. To be able to control what we generate, we need to condition the GAN output on a semantic input, such as the class of an image. In this example, we'll build a Conditional GAN that can generate MNIST handwritten digits conditioned on a given class. Such a model can have various useful applications: let's say you are dealing with an imbalanced image dataset, and you'd like to gather more examples for the skewed class to balance the dataset. Data collection can be a costly process on its own. You could instead train a Conditional GAN and use it to generate novel images for the class that needs balancing. Since the generator learns to associate the generated samples with the class labels, its representations can also be used for other downstream tasks. Following are the references used for developing this example: Conditional Generative Adversarial Nets Lecture on Conditional Generation from Coursera If you need a refresher on GANs, you can refer to the \"Generative adversarial networks\" section of this resource. This example requires TensorFlow 2.5 or higher, as well as TensorFlow Docs, which can be installed using the following command: !pip install -q git+https://github.com/tensorflow/docs Building wheel for tensorflow-docs (setup.py) ... [?25l[?25hdone Imports from tensorflow import keras from tensorflow.keras import layers from tensorflow_docs.vis import embed import matplotlib.pyplot as plt import tensorflow as tf import numpy as np import imageio Constants and hyperparameters batch_size = 64 num_channels = 1 num_classes = 10 image_size = 28 latent_dim = 128 Loading the MNIST dataset and preprocessing it # We'll use all the available examples from both the training and test # sets. (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() all_digits = np.concatenate([x_train, x_test]) all_labels = np.concatenate([y_train, y_test]) # Scale the pixel values to [0, 1] range, add a channel dimension to # the images, and one-hot encode the labels. all_digits = all_digits.astype(\"float32\") / 255.0 all_digits = np.reshape(all_digits, (-1, 28, 28, 1)) all_labels = keras.utils.to_categorical(all_labels, 10) # Create tf.data.Dataset. dataset = tf.data.Dataset.from_tensor_slices((all_digits, all_labels)) dataset = dataset.shuffle(buffer_size=1024).batch(batch_size) print(f\"Shape of training images: {all_digits.shape}\") print(f\"Shape of training labels: {all_labels.shape}\") Shape of training images: (70000, 28, 28, 1) Shape of training labels: (70000, 10) Calculating the number of input channel for the generator and discriminator In a regular (unconditional) GAN, we start by sampling noise (of some fixed dimension) from a normal distribution. In our case, we also need to account for the class labels. We will have to add the number of classes to the input channels of the generator (noise input) as well as the discriminator (generated image input). generator_in_channels = latent_dim + num_classes discriminator_in_channels = num_channels + num_classes print(generator_in_channels, discriminator_in_channels) 138 11 Creating the discriminator and generator The model definitions (discriminator, generator, and ConditionalGAN) have been adapted from this example. # Create the discriminator. discriminator = keras.Sequential( [ keras.layers.InputLayer((28, 28, discriminator_in_channels)), layers.Conv2D(64, (3, 3), strides=(2, 2), padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(128, (3, 3), strides=(2, 2), padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.GlobalMaxPooling2D(), layers.Dense(1), ], name=\"discriminator\", ) # Create the generator. generator = keras.Sequential( [ keras.layers.InputLayer((generator_in_channels,)), # We want to generate 128 + num_classes coefficients to reshape into a # 7x7x(128 + num_classes) map. layers.Dense(7 * 7 * generator_in_channels), layers.LeakyReLU(alpha=0.2), layers.Reshape((7, 7, generator_in_channels)), layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(1, (7, 7), padding=\"same\", activation=\"sigmoid\"), ], name=\"generator\", ) Creating a ConditionalGAN model class ConditionalGAN(keras.Model): def __init__(self, discriminator, generator, latent_dim): super(ConditionalGAN, self).__init__() self.discriminator = discriminator self.generator = generator self.latent_dim = latent_dim self.gen_loss_tracker = keras.metrics.Mean(name=\"generator_loss\") self.disc_loss_tracker = keras.metrics.Mean(name=\"discriminator_loss\") @property def metrics(self): return [self.gen_loss_tracker, self.disc_loss_tracker] def compile(self, d_optimizer, g_optimizer, loss_fn): super(ConditionalGAN, self).compile() self.d_optimizer = d_optimizer self.g_optimizer = g_optimizer self.loss_fn = loss_fn def train_step(self, data): # Unpack the data. real_images, one_hot_labels = data # Add dummy dimensions to the labels so that they can be concatenated with # the images. This is for the discriminator. image_one_hot_labels = one_hot_labels[:, :, None, None] image_one_hot_labels = tf.repeat( image_one_hot_labels, repeats=[image_size * image_size] ) image_one_hot_labels = tf.reshape( image_one_hot_labels, (-1, image_size, image_size, num_classes) ) # Sample random points in the latent space and concatenate the labels. # This is for the generator. batch_size = tf.shape(real_images)[0] random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim)) random_vector_labels = tf.concat( [random_latent_vectors, one_hot_labels], axis=1 ) # Decode the noise (guided by labels) to fake images. generated_images = self.generator(random_vector_labels) # Combine them with real images. Note that we are concatenating the labels # with these images here. fake_image_and_labels = tf.concat([generated_images, image_one_hot_labels], -1) real_image_and_labels = tf.concat([real_images, image_one_hot_labels], -1) combined_images = tf.concat( [fake_image_and_labels, real_image_and_labels], axis=0 ) # Assemble labels discriminating real from fake images. labels = tf.concat( [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0 ) # Train the discriminator. with tf.GradientTape() as tape: predictions = self.discriminator(combined_images) d_loss = self.loss_fn(labels, predictions) grads = tape.gradient(d_loss, self.discriminator.trainable_weights) self.d_optimizer.apply_gradients( zip(grads, self.discriminator.trainable_weights) ) # Sample random points in the latent space. random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim)) random_vector_labels = tf.concat( [random_latent_vectors, one_hot_labels], axis=1 ) # Assemble labels that say \"all real images\". misleading_labels = tf.zeros((batch_size, 1)) # Train the generator (note that we should *not* update the weights # of the discriminator)! with tf.GradientTape() as tape: fake_images = self.generator(random_vector_labels) fake_image_and_labels = tf.concat([fake_images, image_one_hot_labels], -1) predictions = self.discriminator(fake_image_and_labels) g_loss = self.loss_fn(misleading_labels, predictions) grads = tape.gradient(g_loss, self.generator.trainable_weights) self.g_optimizer.apply_gradients(zip(grads, self.generator.trainable_weights)) # Monitor loss. self.gen_loss_tracker.update_state(g_loss) self.disc_loss_tracker.update_state(d_loss) return { \"g_loss\": self.gen_loss_tracker.result(), \"d_loss\": self.disc_loss_tracker.result(), } Training the Conditional GAN cond_gan = ConditionalGAN( discriminator=discriminator, generator=generator, latent_dim=latent_dim ) cond_gan.compile( d_optimizer=keras.optimizers.Adam(learning_rate=0.0003), g_optimizer=keras.optimizers.Adam(learning_rate=0.0003), loss_fn=keras.losses.BinaryCrossentropy(from_logits=True), ) cond_gan.fit(dataset, epochs=20) Epoch 1/20 1094/1094 [==============================] - 34s 16ms/step - g_loss: 1.4316 - d_loss: 0.4501 Epoch 2/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 1.2608 - d_loss: 0.4962 Epoch 3/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 1.4321 - d_loss: 0.4443 Epoch 4/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 1.9275 - d_loss: 0.2990 Epoch 5/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 2.2511 - d_loss: 0.2491 Epoch 6/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.9803 - d_loss: 0.6354 Epoch 7/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.8971 - d_loss: 0.6596 Epoch 8/20 1094/1094 [==============================] - 17s 16ms/step - g_loss: 0.8358 - d_loss: 0.6748 Epoch 9/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.8089 - d_loss: 0.6726 Epoch 10/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7995 - d_loss: 0.6739 Epoch 11/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7873 - d_loss: 0.6789 Epoch 12/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7666 - d_loss: 0.6820 Epoch 13/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7637 - d_loss: 0.6839 Epoch 14/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7572 - d_loss: 0.6840 Epoch 15/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7563 - d_loss: 0.6795 Epoch 16/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7469 - d_loss: 0.6855 Epoch 17/20 1094/1094 [==============================] - 18s 16ms/step - g_loss: 0.7623 - d_loss: 0.6798 Epoch 18/20 889/1094 [=======================>......] - ETA: 3s - g_loss: 0.7421 - d_loss: 0.6802 Interpolating between classes with the trained generator # We first extract the trained generator from our Conditiona GAN. trained_gen = cond_gan.generator # Choose the number of intermediate images that would be generated in # between the interpolation + 2 (start and last images). num_interpolation = 9 # @param {type:\"integer\"} # Sample noise for the interpolation. interpolation_noise = tf.random.normal(shape=(1, latent_dim)) interpolation_noise = tf.repeat(interpolation_noise, repeats=num_interpolation) interpolation_noise = tf.reshape(interpolation_noise, (num_interpolation, latent_dim)) def interpolate_class(first_number, second_number): # Convert the start and end labels to one-hot encoded vectors. first_label = keras.utils.to_categorical([first_number], num_classes) second_label = keras.utils.to_categorical([second_number], num_classes) first_label = tf.cast(first_label, tf.float32) second_label = tf.cast(second_label, tf.float32) # Calculate the interpolation vector between the two labels. percent_second_label = tf.linspace(0, 1, num_interpolation)[:, None] percent_second_label = tf.cast(percent_second_label, tf.float32) interpolation_labels = ( first_label * (1 - percent_second_label) + second_label * percent_second_label ) # Combine the noise and the labels and run inference with the generator. noise_and_labels = tf.concat([interpolation_noise, interpolation_labels], 1) fake = trained_gen.predict(noise_and_labels) return fake start_class = 1 # @param {type:\"slider\", min:0, max:9, step:1} end_class = 5 # @param {type:\"slider\", min:0, max:9, step:1} fake_images = interpolate_class(start_class, end_class) Here, we first sample noise from a normal distribution and then we repeat that for num_interpolation times and reshape the result accordingly. We then distribute it uniformly for num_interpolation with the label indentities being present in some proportion. fake_images *= 255.0 converted_images = fake_images.astype(np.uint8) converted_images = tf.image.resize(converted_images, (96, 96)).numpy().astype(np.uint8) imageio.mimsave(\"animation.gif\", converted_images, fps=1) embed.embed_file(\"animation.gif\") We can further improve the performance of this model with recipes like WGAN-GP. Conditional generation is also widely used in many modern image generation architectures like VQ-GANs, DALL-E, etc. Implementation of CycleGAN. CycleGAN CycleGAN is a model that aims to solve the image-to-image translation problem. The goal of the image-to-image translation problem is to learn the mapping between an input image and an output image using a training set of aligned image pairs. However, obtaining paired examples isn't always feasible. CycleGAN tries to learn this mapping without requiring paired input-output images, using cycle-consistent adversarial networks. Paper Original implementation Setup import os import numpy as np import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_addons as tfa import tensorflow_datasets as tfds tfds.disable_progress_bar() autotune = tf.data.AUTOTUNE Prepare the dataset In this example, we will be using the horse to zebra dataset. # Load the horse-zebra dataset using tensorflow-datasets. dataset, _ = tfds.load(\"cycle_gan/horse2zebra\", with_info=True, as_supervised=True) train_horses, train_zebras = dataset[\"trainA\"], dataset[\"trainB\"] test_horses, test_zebras = dataset[\"testA\"], dataset[\"testB\"] # Define the standard image size. orig_img_size = (286, 286) # Size of the random crops to be used during training. input_img_size = (256, 256, 3) # Weights initializer for the layers. kernel_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02) # Gamma initializer for instance normalization. gamma_init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02) buffer_size = 256 batch_size = 1 def normalize_img(img): img = tf.cast(img, dtype=tf.float32) # Map values in the range [-1, 1] return (img / 127.5) - 1.0 def preprocess_train_image(img, label): # Random flip img = tf.image.random_flip_left_right(img) # Resize to the original size first img = tf.image.resize(img, [*orig_img_size]) # Random crop to 256X256 img = tf.image.random_crop(img, size=[*input_img_size]) # Normalize the pixel values in the range [-1, 1] img = normalize_img(img) return img def preprocess_test_image(img, label): # Only resizing and normalization for the test images. img = tf.image.resize(img, [input_img_size[0], input_img_size[1]]) img = normalize_img(img) return img Create Dataset objects # Apply the preprocessing operations to the training data train_horses = ( train_horses.map(preprocess_train_image, num_parallel_calls=autotune) .cache() .shuffle(buffer_size) .batch(batch_size) ) train_zebras = ( train_zebras.map(preprocess_train_image, num_parallel_calls=autotune) .cache() .shuffle(buffer_size) .batch(batch_size) ) # Apply the preprocessing operations to the test data test_horses = ( test_horses.map(preprocess_test_image, num_parallel_calls=autotune) .cache() .shuffle(buffer_size) .batch(batch_size) ) test_zebras = ( test_zebras.map(preprocess_test_image, num_parallel_calls=autotune) .cache() .shuffle(buffer_size) .batch(batch_size) ) Visualize some samples _, ax = plt.subplots(4, 2, figsize=(10, 15)) for i, samples in enumerate(zip(train_horses.take(4), train_zebras.take(4))): horse = (((samples[0][0] * 127.5) + 127.5).numpy()).astype(np.uint8) zebra = (((samples[1][0] * 127.5) + 127.5).numpy()).astype(np.uint8) ax[i, 0].imshow(horse) ax[i, 1].imshow(zebra) plt.show() png Building blocks used in the CycleGAN generators and discriminators class ReflectionPadding2D(layers.Layer): \"\"\"Implements Reflection Padding as a layer. Args: padding(tuple): Amount of padding for the spatial dimensions. Returns: A padded tensor with the same type as the input tensor. \"\"\" def __init__(self, padding=(1, 1), **kwargs): self.padding = tuple(padding) super(ReflectionPadding2D, self).__init__(**kwargs) def call(self, input_tensor, mask=None): padding_width, padding_height = self.padding padding_tensor = [ [0, 0], [padding_height, padding_height], [padding_width, padding_width], [0, 0], ] return tf.pad(input_tensor, padding_tensor, mode=\"REFLECT\") def residual_block( x, activation, kernel_initializer=kernel_init, kernel_size=(3, 3), strides=(1, 1), padding=\"valid\", gamma_initializer=gamma_init, use_bias=False, ): dim = x.shape[-1] input_tensor = x x = ReflectionPadding2D()(input_tensor) x = layers.Conv2D( dim, kernel_size, strides=strides, kernel_initializer=kernel_initializer, padding=padding, use_bias=use_bias, )(x) x = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(x) x = activation(x) x = ReflectionPadding2D()(x) x = layers.Conv2D( dim, kernel_size, strides=strides, kernel_initializer=kernel_initializer, padding=padding, use_bias=use_bias, )(x) x = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(x) x = layers.add([input_tensor, x]) return x def downsample( x, filters, activation, kernel_initializer=kernel_init, kernel_size=(3, 3), strides=(2, 2), padding=\"same\", gamma_initializer=gamma_init, use_bias=False, ): x = layers.Conv2D( filters, kernel_size, strides=strides, kernel_initializer=kernel_initializer, padding=padding, use_bias=use_bias, )(x) x = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(x) if activation: x = activation(x) return x def upsample( x, filters, activation, kernel_size=(3, 3), strides=(2, 2), padding=\"same\", kernel_initializer=kernel_init, gamma_initializer=gamma_init, use_bias=False, ): x = layers.Conv2DTranspose( filters, kernel_size, strides=strides, padding=padding, kernel_initializer=kernel_initializer, use_bias=use_bias, )(x) x = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(x) if activation: x = activation(x) return x Build the generators The generator consists of downsampling blocks: nine residual blocks and upsampling blocks. The structure of the generator is the following: c7s1-64 ==> Conv block with `relu` activation, filter size of 7 d128 ====| |-> 2 downsampling blocks d256 ====| R256 ====| R256 | R256 | R256 | R256 |-> 9 residual blocks R256 | R256 | R256 | R256 ====| u128 ====| |-> 2 upsampling blocks u64 ====| c7s1-3 => Last conv block with `tanh` activation, filter size of 7. def get_resnet_generator( filters=64, num_downsampling_blocks=2, num_residual_blocks=9, num_upsample_blocks=2, gamma_initializer=gamma_init, name=None, ): img_input = layers.Input(shape=input_img_size, name=name + \"_img_input\") x = ReflectionPadding2D(padding=(3, 3))(img_input) x = layers.Conv2D(filters, (7, 7), kernel_initializer=kernel_init, use_bias=False)( x ) x = tfa.layers.InstanceNormalization(gamma_initializer=gamma_initializer)(x) x = layers.Activation(\"relu\")(x) # Downsampling for _ in range(num_downsampling_blocks): filters *= 2 x = downsample(x, filters=filters, activation=layers.Activation(\"relu\")) # Residual blocks for _ in range(num_residual_blocks): x = residual_block(x, activation=layers.Activation(\"relu\")) # Upsampling for _ in range(num_upsample_blocks): filters //= 2 x = upsample(x, filters, activation=layers.Activation(\"relu\")) # Final block x = ReflectionPadding2D(padding=(3, 3))(x) x = layers.Conv2D(3, (7, 7), padding=\"valid\")(x) x = layers.Activation(\"tanh\")(x) model = keras.models.Model(img_input, x, name=name) return model Build the discriminators The discriminators implement the following architecture: C64->C128->C256->C512 def get_discriminator( filters=64, kernel_initializer=kernel_init, num_downsampling=3, name=None ): img_input = layers.Input(shape=input_img_size, name=name + \"_img_input\") x = layers.Conv2D( filters, (4, 4), strides=(2, 2), padding=\"same\", kernel_initializer=kernel_initializer, )(img_input) x = layers.LeakyReLU(0.2)(x) num_filters = filters for num_downsample_block in range(3): num_filters *= 2 if num_downsample_block < 2: x = downsample( x, filters=num_filters, activation=layers.LeakyReLU(0.2), kernel_size=(4, 4), strides=(2, 2), ) else: x = downsample( x, filters=num_filters, activation=layers.LeakyReLU(0.2), kernel_size=(4, 4), strides=(1, 1), ) x = layers.Conv2D( 1, (4, 4), strides=(1, 1), padding=\"same\", kernel_initializer=kernel_initializer )(x) model = keras.models.Model(inputs=img_input, outputs=x, name=name) return model # Get the generators gen_G = get_resnet_generator(name=\"generator_G\") gen_F = get_resnet_generator(name=\"generator_F\") # Get the discriminators disc_X = get_discriminator(name=\"discriminator_X\") disc_Y = get_discriminator(name=\"discriminator_Y\") Build the CycleGAN model We will override the train_step() method of the Model class for training via fit(). class CycleGan(keras.Model): def __init__( self, generator_G, generator_F, discriminator_X, discriminator_Y, lambda_cycle=10.0, lambda_identity=0.5, ): super(CycleGan, self).__init__() self.gen_G = generator_G self.gen_F = generator_F self.disc_X = discriminator_X self.disc_Y = discriminator_Y self.lambda_cycle = lambda_cycle self.lambda_identity = lambda_identity def compile( self, gen_G_optimizer, gen_F_optimizer, disc_X_optimizer, disc_Y_optimizer, gen_loss_fn, disc_loss_fn, ): super(CycleGan, self).compile() self.gen_G_optimizer = gen_G_optimizer self.gen_F_optimizer = gen_F_optimizer self.disc_X_optimizer = disc_X_optimizer self.disc_Y_optimizer = disc_Y_optimizer self.generator_loss_fn = gen_loss_fn self.discriminator_loss_fn = disc_loss_fn self.cycle_loss_fn = keras.losses.MeanAbsoluteError() self.identity_loss_fn = keras.losses.MeanAbsoluteError() def train_step(self, batch_data): # x is Horse and y is zebra real_x, real_y = batch_data # For CycleGAN, we need to calculate different # kinds of losses for the generators and discriminators. # We will perform the following steps here: # # 1. Pass real images through the generators and get the generated images # 2. Pass the generated images back to the generators to check if we # we can predict the original image from the generated image. # 3. Do an identity mapping of the real images using the generators. # 4. Pass the generated images in 1) to the corresponding discriminators. # 5. Calculate the generators total loss (adverserial + cycle + identity) # 6. Calculate the discriminators loss # 7. Update the weights of the generators # 8. Update the weights of the discriminators # 9. Return the losses in a dictionary with tf.GradientTape(persistent=True) as tape: # Horse to fake zebra fake_y = self.gen_G(real_x, training=True) # Zebra to fake horse -> y2x fake_x = self.gen_F(real_y, training=True) # Cycle (Horse to fake zebra to fake horse): x -> y -> x cycled_x = self.gen_F(fake_y, training=True) # Cycle (Zebra to fake horse to fake zebra) y -> x -> y cycled_y = self.gen_G(fake_x, training=True) # Identity mapping same_x = self.gen_F(real_x, training=True) same_y = self.gen_G(real_y, training=True) # Discriminator output disc_real_x = self.disc_X(real_x, training=True) disc_fake_x = self.disc_X(fake_x, training=True) disc_real_y = self.disc_Y(real_y, training=True) disc_fake_y = self.disc_Y(fake_y, training=True) # Generator adverserial loss gen_G_loss = self.generator_loss_fn(disc_fake_y) gen_F_loss = self.generator_loss_fn(disc_fake_x) # Generator cycle loss cycle_loss_G = self.cycle_loss_fn(real_y, cycled_y) * self.lambda_cycle cycle_loss_F = self.cycle_loss_fn(real_x, cycled_x) * self.lambda_cycle # Generator identity loss id_loss_G = ( self.identity_loss_fn(real_y, same_y) * self.lambda_cycle * self.lambda_identity ) id_loss_F = ( self.identity_loss_fn(real_x, same_x) * self.lambda_cycle * self.lambda_identity ) # Total generator loss total_loss_G = gen_G_loss + cycle_loss_G + id_loss_G total_loss_F = gen_F_loss + cycle_loss_F + id_loss_F # Discriminator loss disc_X_loss = self.discriminator_loss_fn(disc_real_x, disc_fake_x) disc_Y_loss = self.discriminator_loss_fn(disc_real_y, disc_fake_y) # Get the gradients for the generators grads_G = tape.gradient(total_loss_G, self.gen_G.trainable_variables) grads_F = tape.gradient(total_loss_F, self.gen_F.trainable_variables) # Get the gradients for the discriminators disc_X_grads = tape.gradient(disc_X_loss, self.disc_X.trainable_variables) disc_Y_grads = tape.gradient(disc_Y_loss, self.disc_Y.trainable_variables) # Update the weights of the generators self.gen_G_optimizer.apply_gradients( zip(grads_G, self.gen_G.trainable_variables) ) self.gen_F_optimizer.apply_gradients( zip(grads_F, self.gen_F.trainable_variables) ) # Update the weights of the discriminators self.disc_X_optimizer.apply_gradients( zip(disc_X_grads, self.disc_X.trainable_variables) ) self.disc_Y_optimizer.apply_gradients( zip(disc_Y_grads, self.disc_Y.trainable_variables) ) return { \"G_loss\": total_loss_G, \"F_loss\": total_loss_F, \"D_X_loss\": disc_X_loss, \"D_Y_loss\": disc_Y_loss, } Create a callback that periodically saves generated images class GANMonitor(keras.callbacks.Callback): \"\"\"A callback to generate and save images after each epoch\"\"\" def __init__(self, num_img=4): self.num_img = num_img def on_epoch_end(self, epoch, logs=None): _, ax = plt.subplots(4, 2, figsize=(12, 12)) for i, img in enumerate(test_horses.take(self.num_img)): prediction = self.model.gen_G(img)[0].numpy() prediction = (prediction * 127.5 + 127.5).astype(np.uint8) img = (img[0] * 127.5 + 127.5).numpy().astype(np.uint8) ax[i, 0].imshow(img) ax[i, 1].imshow(prediction) ax[i, 0].set_title(\"Input image\") ax[i, 1].set_title(\"Translated image\") ax[i, 0].axis(\"off\") ax[i, 1].axis(\"off\") prediction = keras.preprocessing.image.array_to_img(prediction) prediction.save( \"generated_img_{i}_{epoch}.png\".format(i=i, epoch=epoch + 1) ) plt.show() plt.close() Train the end-to-end model # Loss function for evaluating adversarial loss adv_loss_fn = keras.losses.MeanSquaredError() # Define the loss function for the generators def generator_loss_fn(fake): fake_loss = adv_loss_fn(tf.ones_like(fake), fake) return fake_loss # Define the loss function for the discriminators def discriminator_loss_fn(real, fake): real_loss = adv_loss_fn(tf.ones_like(real), real) fake_loss = adv_loss_fn(tf.zeros_like(fake), fake) return (real_loss + fake_loss) * 0.5 # Create cycle gan model cycle_gan_model = CycleGan( generator_G=gen_G, generator_F=gen_F, discriminator_X=disc_X, discriminator_Y=disc_Y ) # Compile the model cycle_gan_model.compile( gen_G_optimizer=keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5), gen_F_optimizer=keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5), disc_X_optimizer=keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5), disc_Y_optimizer=keras.optimizers.Adam(learning_rate=2e-4, beta_1=0.5), gen_loss_fn=generator_loss_fn, disc_loss_fn=discriminator_loss_fn, ) # Callbacks plotter = GANMonitor() checkpoint_filepath = \"./model_checkpoints/cyclegan_checkpoints.{epoch:03d}\" model_checkpoint_callback = keras.callbacks.ModelCheckpoint( filepath=checkpoint_filepath ) # Here we will train the model for just one epoch as each epoch takes around # 7 minutes on a single P100 backed machine. cycle_gan_model.fit( tf.data.Dataset.zip((train_horses, train_zebras)), epochs=1, callbacks=[plotter, model_checkpoint_callback], ) 1067/1067 [==============================] - ETA: 0s - G_loss: 4.4794 - F_loss: 4.1048 - D_X_loss: 0.1584 - D_Y_loss: 0.1233 png 1067/1067 [==============================] - 390s 366ms/step - G_loss: 4.4783 - F_loss: 4.1035 - D_X_loss: 0.1584 - D_Y_loss: 0.1232 Test the performance of the model. # This model was trained for 90 epochs. We will be loading those weights # here. Once the weights are loaded, we will take a few samples from the test # data and check the model's performance. !curl -LO https://github.com/AakashKumarNain/CycleGAN_TF2/releases/download/v1.0/saved_checkpoints.zip !unzip -qq saved_checkpoints.zip # Load the checkpoints weight_file = \"./saved_checkpoints/cyclegan_checkpoints.090\" cycle_gan_model.load_weights(weight_file).expect_partial() print(\"Weights loaded successfully\") _, ax = plt.subplots(4, 2, figsize=(10, 15)) for i, img in enumerate(test_horses.take(4)): prediction = cycle_gan_model.gen_G(img, training=False)[0].numpy() prediction = (prediction * 127.5 + 127.5).astype(np.uint8) img = (img[0] * 127.5 + 127.5).numpy().astype(np.uint8) ax[i, 0].imshow(img) ax[i, 1].imshow(prediction) ax[i, 0].set_title(\"Input image\") ax[i, 0].set_title(\"Input image\") ax[i, 1].set_title(\"Translated image\") ax[i, 0].axis(\"off\") ax[i, 1].axis(\"off\") prediction = keras.preprocessing.image.array_to_img(prediction) prediction.save(\"predicted_img_{i}.png\".format(i=i)) plt.tight_layout() plt.show() % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 634 100 634 0 0 2874 0 --:--:-- --:--:-- --:--:-- 2881 100 273M 100 273M 0 0 1736k 0 0:02:41 0:02:41 --:--:-- 2049k Weights loaded successfully png Generating images from limited data using the Caltech Birds dataset. Introduction GANs Generative Adversarial Networks (GANs) are a popular class of generative deep learning models, commonly used for image generation. They consist of a pair of dueling neural networks, called the discriminator and the generator. The discriminator's task is to distinguish real images from generated (fake) ones, while the generator network tries to fool the discriminator by generating more and more realistic images. If the generator is however too easy or too hard to fool, it might fail to provide useful learning signal for the generator, therefore training GANs is usually considered a difficult task. Data augmentation for GANS Data augmentation, a popular technique in deep learning, is the process of randomly applying semantics-preserving transformations to the input data to generate multiple realistic versions of it, thereby effectively multiplying the amount of training data available. The simplest example is left-right flipping an image, which preserves its contents while generating a second unique training sample. Data augmentation is commonly used in supervised learning to prevent overfitting and enhance generalization. The authors of StyleGAN2-ADA show that discriminator overfitting can be an issue in GANs, especially when only low amounts of training data is available. They propose Adaptive Discriminator Augmentation to mitigate this issue. Applying data augmentation to GANs however is not straightforward. Since the generator is updated using the discriminator's gradients, if the generated images are augmented, the augmentation pipeline has to be differentiable and also has to be GPU-compatible for computational efficiency. Luckily, the Keras image augmentation layers fulfill both these requirements, and are therefore very well suited for this task. Invertible data augmentation A possible difficulty when using data augmentation in generative models is the issue of \"leaky augmentations\" (section 2.2), namely when the model generates images that are already augmented. This would mean that it was not able to separate the augmentation from the underlying data distribution, which can be caused by using non-invertible data transformations. For example, if either 0, 90, 180 or 270 degree rotations are performed with equal probability, the original orientation of the images is impossible to infer, and this information is destroyed. A simple trick to make data augmentations invertible is to only apply them with some probability. That way the original version of the images will be more common, and the data distribution can be infered. By properly choosing this probability, one can effectively regularize the discriminator without making the augmentations leaky. Setup import matplotlib.pyplot as plt import tensorflow as tf import tensorflow_datasets as tfds from tensorflow import keras from tensorflow.keras import layers Hyperparameterers # data num_epochs = 10 # train for 400 epochs for good results image_size = 64 # resolution of Kernel Inception Distance measurement, see related section kid_image_size = 75 padding = 0.25 dataset_name = \"caltech_birds2011\" # adaptive discriminator augmentation max_translation = 0.125 max_rotation = 0.125 max_zoom = 0.25 target_accuracy = 0.85 integration_steps = 1000 # architecture noise_size = 64 depth = 4 width = 128 leaky_relu_slope = 0.2 dropout_rate = 0.4 # optimization batch_size = 128 learning_rate = 2e-4 beta_1 = 0.5 # not using the default value of 0.9 is important ema = 0.99 Data pipeline In this example, we will use the Caltech Birds (2011) dataset for generating images of birds, which is a diverse natural dataset containing less then 6000 images for training. When working with such low amounts of data, one has to take extra care to retain as high data quality as possible. In this example, we use the provided bounding boxes of the birds to cut them out with square crops while preserving their aspect ratios when possible. def round_to_int(float_value): return tf.cast(tf.math.round(float_value), dtype=tf.int32) def preprocess_image(data): # unnormalize bounding box coordinates height = tf.cast(tf.shape(data[\"image\"])[0], dtype=tf.float32) width = tf.cast(tf.shape(data[\"image\"])[1], dtype=tf.float32) bounding_box = data[\"bbox\"] * tf.stack([height, width, height, width]) # calculate center and length of longer side, add padding target_center_y = 0.5 * (bounding_box[0] + bounding_box[2]) target_center_x = 0.5 * (bounding_box[1] + bounding_box[3]) target_size = tf.maximum( (1.0 + padding) * (bounding_box[2] - bounding_box[0]), (1.0 + padding) * (bounding_box[3] - bounding_box[1]), ) # modify crop size to fit into image target_height = tf.reduce_min( [target_size, 2.0 * target_center_y, 2.0 * (height - target_center_y)] ) target_width = tf.reduce_min( [target_size, 2.0 * target_center_x, 2.0 * (width - target_center_x)] ) # crop image image = tf.image.crop_to_bounding_box( data[\"image\"], offset_height=round_to_int(target_center_y - 0.5 * target_height), offset_width=round_to_int(target_center_x - 0.5 * target_width), target_height=round_to_int(target_height), target_width=round_to_int(target_width), ) # resize and clip # for image downsampling, area interpolation is the preferred method image = tf.image.resize( image, size=[image_size, image_size], method=tf.image.ResizeMethod.AREA ) return tf.clip_by_value(image / 255.0, 0.0, 1.0) def prepare_dataset(split): # the validation dataset is shuffled as well, because data order matters # for the KID calculation return ( tfds.load(dataset_name, split=split, shuffle_files=True) .map(preprocess_image, num_parallel_calls=tf.data.AUTOTUNE) .cache() .shuffle(10 * batch_size) .batch(batch_size, drop_remainder=True) .prefetch(buffer_size=tf.data.AUTOTUNE) ) train_dataset = prepare_dataset(\"train\") val_dataset = prepare_dataset(\"test\") After preprocessing the training images look like the following: birds dataset Kernel inception distance Kernel Inception Distance (KID) was proposed as a replacement for the popular Frechet Inception Distance (FID) metric for measuring image generation quality. Both metrics measure the difference in the generated and training distributions in the representation space of an InceptionV3 network pretrained on ImageNet. According to the paper, KID was proposed because FID has no unbiased estimator, its expected value is higher when it is measured on fewer images. KID is more suitable for small datasets because its expected value does not depend on the number of samples it is measured on. In my experience it is also computationally lighter, numerically more stable, and simpler to implement because it can be estimated in a per-batch manner. In this example, the images are evaluated at the minimal possible resolution of the Inception network (75x75 instead of 299x299), and the metric is only measured on the validation set for computational efficiency. class KID(keras.metrics.Metric): def __init__(self, name=\"kid\", **kwargs): super().__init__(name=name, **kwargs) # KID is estimated per batch and is averaged across batches self.kid_tracker = keras.metrics.Mean() # a pretrained InceptionV3 is used without its classification layer # transform the pixel values to the 0-255 range, then use the same # preprocessing as during pretraining self.encoder = keras.Sequential( [ layers.InputLayer(input_shape=(image_size, image_size, 3)), layers.Rescaling(255.0), layers.Resizing(height=kid_image_size, width=kid_image_size), layers.Lambda(keras.applications.inception_v3.preprocess_input), keras.applications.InceptionV3( include_top=False, input_shape=(kid_image_size, kid_image_size, 3), weights=\"imagenet\", ), layers.GlobalAveragePooling2D(), ], name=\"inception_encoder\", ) def polynomial_kernel(self, features_1, features_2): feature_dimensions = tf.cast(tf.shape(features_1)[1], dtype=tf.float32) return (features_1 @ tf.transpose(features_2) / feature_dimensions + 1.0) ** 3.0 def update_state(self, real_images, generated_images, sample_weight=None): real_features = self.encoder(real_images, training=False) generated_features = self.encoder(generated_images, training=False) # compute polynomial kernels using the two sets of features kernel_real = self.polynomial_kernel(real_features, real_features) kernel_generated = self.polynomial_kernel( generated_features, generated_features ) kernel_cross = self.polynomial_kernel(real_features, generated_features) # estimate the squared maximum mean discrepancy using the average kernel values batch_size = tf.shape(real_features)[0] batch_size_f = tf.cast(batch_size, dtype=tf.float32) mean_kernel_real = tf.reduce_sum(kernel_real * (1.0 - tf.eye(batch_size))) / ( batch_size_f * (batch_size_f - 1.0) ) mean_kernel_generated = tf.reduce_sum( kernel_generated * (1.0 - tf.eye(batch_size)) ) / (batch_size_f * (batch_size_f - 1.0)) mean_kernel_cross = tf.reduce_mean(kernel_cross) kid = mean_kernel_real + mean_kernel_generated - 2.0 * mean_kernel_cross # update the average KID estimate self.kid_tracker.update_state(kid) def result(self): return self.kid_tracker.result() def reset_state(self): self.kid_tracker.reset_state() Adaptive discriminator augmentation The authors of StyleGAN2-ADA propose to change the augmentation probability adaptively during training. Though it is explained differently in the paper, they use integral control on the augmentation probability to keep the discriminator's accuracy on real images close to a target value. Note, that their controlled variable is actually the average sign of the discriminator logits (r_t in the paper), which corresponds to 2 * accuracy - 1. This method requires two hyperparameters: target_accuracy: the target value for the discriminator's accuracy on real images. I recommend selecting its value from the 80-90% range. integration_steps: the number of update steps required for an accuracy error of 100% to transform into an augmentation probability increase of 100%. To give an intuition, this defines how slowly the augmentation probability is changed. I recommend setting this to a relatively high value (1000 in this case) so that the augmentation strength is only adjusted slowly. The main motivation for this procedure is that the optimal value of the target accuracy is similar across different dataset sizes (see figure 4 and 5 in the paper), so it does not have to be retuned, because the process automatically applies stronger data augmentation when it is needed. # \"hard sigmoid\", useful for binary accuracy calculation from logits def step(values): # negative values -> 0.0, positive values -> 1.0 return 0.5 * (1.0 + tf.sign(values)) # augments images with a probability that is dynamically updated during training class AdaptiveAugmenter(keras.Model): def __init__(self): super().__init__() # stores the current probability of an image being augmented self.probability = tf.Variable(0.0) # the corresponding augmentation names from the paper are shown above each layer # the authors show (see figure 4), that the blitting and geometric augmentations # are the most helpful in the low-data regime self.augmenter = keras.Sequential( [ layers.InputLayer(input_shape=(image_size, image_size, 3)), # blitting/x-flip: layers.RandomFlip(\"horizontal\"), # blitting/integer translation: layers.RandomTranslation( height_factor=max_translation, width_factor=max_translation, interpolation=\"nearest\", ), # geometric/rotation: layers.RandomRotation(factor=max_rotation), # geometric/isotropic and anisotropic scaling: layers.RandomZoom( height_factor=(-max_zoom, 0.0), width_factor=(-max_zoom, 0.0) ), ], name=\"adaptive_augmenter\", ) def call(self, images, training): if training: augmented_images = self.augmenter(images, training) # during training either the original or the augmented images are selected # based on self.probability augmentation_values = tf.random.uniform( shape=(batch_size, 1, 1, 1), minval=0.0, maxval=1.0 ) augmentation_bools = tf.math.less(augmentation_values, self.probability) images = tf.where(augmentation_bools, augmented_images, images) return images def update(self, real_logits): current_accuracy = tf.reduce_mean(step(real_logits)) # the augmentation probability is updated based on the dicriminator's # accuracy on real images accuracy_error = current_accuracy - target_accuracy self.probability.assign( tf.clip_by_value( self.probability + accuracy_error / integration_steps, 0.0, 1.0 ) ) Network architecture Here we specify the architecture of the two networks: generator: maps a random vector to an image, which should be as realistic as possible discriminator: maps an image to a scalar score, which should be high for real and low for generated images GANs tend to be sensitive to the network architecture, I implemented a DCGAN architecture in this example, because it is relatively stable during training while being simple to implement. We use a constant number of filters throughout the network, use a sigmoid instead of tanh in the last layer of the generator, and use default initialization instead of random normal as further simplifications. As a good practice, we disable the learnable scale parameter in the batch normalization layers, because on one hand the following relu + convolutional layers make it redundant (as noted in the documentation). But also because it should be disabled based on theory when using spectral normalization (section 4.1), which is not used here, but is common in GANs. We also disable the bias in the fully connected and convolutional layers, because the following batch normalization makes it redundant. # DCGAN generator def get_generator(): noise_input = keras.Input(shape=(noise_size,)) x = layers.Dense(4 * 4 * width, use_bias=False)(noise_input) x = layers.BatchNormalization(scale=False)(x) x = layers.ReLU()(x) x = layers.Reshape(target_shape=(4, 4, width))(x) for _ in range(depth - 1): x = layers.Conv2DTranspose( width, kernel_size=4, strides=2, padding=\"same\", use_bias=False, )(x) x = layers.BatchNormalization(scale=False)(x) x = layers.ReLU()(x) image_output = layers.Conv2DTranspose( 3, kernel_size=4, strides=2, padding=\"same\", activation=\"sigmoid\", )(x) return keras.Model(noise_input, image_output, name=\"generator\") # DCGAN discriminator def get_discriminator(): image_input = keras.Input(shape=(image_size, image_size, 3)) x = image_input for _ in range(depth): x = layers.Conv2D( width, kernel_size=4, strides=2, padding=\"same\", use_bias=False, )(x) x = layers.BatchNormalization(scale=False)(x) x = layers.LeakyReLU(alpha=leaky_relu_slope)(x) x = layers.Flatten()(x) x = layers.Dropout(dropout_rate)(x) output_score = layers.Dense(1)(x) return keras.Model(image_input, output_score, name=\"discriminator\") GAN model class GAN_ADA(keras.Model): def __init__(self): super().__init__() self.augmenter = AdaptiveAugmenter() self.generator = get_generator() self.ema_generator = keras.models.clone_model(self.generator) self.discriminator = get_discriminator() self.generator.summary() self.discriminator.summary() def compile(self, generator_optimizer, discriminator_optimizer, **kwargs): super().compile(**kwargs) # separate optimizers for the two networks self.generator_optimizer = generator_optimizer self.discriminator_optimizer = discriminator_optimizer self.generator_loss_tracker = keras.metrics.Mean(name=\"g_loss\") self.discriminator_loss_tracker = keras.metrics.Mean(name=\"d_loss\") self.real_accuracy = keras.metrics.BinaryAccuracy(name=\"real_acc\") self.generated_accuracy = keras.metrics.BinaryAccuracy(name=\"gen_acc\") self.augmentation_probability_tracker = keras.metrics.Mean(name=\"aug_p\") self.kid = KID() @property def metrics(self): return [ self.generator_loss_tracker, self.discriminator_loss_tracker, self.real_accuracy, self.generated_accuracy, self.augmentation_probability_tracker, self.kid, ] def generate(self, batch_size, training): latent_samples = tf.random.normal(shape=(batch_size, noise_size)) # use ema_generator during inference if training: generated_images = self.generator(latent_samples, training) else: generated_images = self.ema_generator(latent_samples, training) return generated_images def adversarial_loss(self, real_logits, generated_logits): # this is usually called the non-saturating GAN loss real_labels = tf.ones(shape=(batch_size, 1)) generated_labels = tf.zeros(shape=(batch_size, 1)) # the generator tries to produce images that the discriminator considers as real generator_loss = keras.losses.binary_crossentropy( real_labels, generated_logits, from_logits=True ) # the discriminator tries to determine if images are real or generated discriminator_loss = keras.losses.binary_crossentropy( tf.concat([real_labels, generated_labels], axis=0), tf.concat([real_logits, generated_logits], axis=0), from_logits=True, ) return tf.reduce_mean(generator_loss), tf.reduce_mean(discriminator_loss) def train_step(self, real_images): real_images = self.augmenter(real_images, training=True) # use persistent gradient tape because gradients will be calculated twice with tf.GradientTape(persistent=True) as tape: generated_images = self.generate(batch_size, training=True) # gradient is calculated through the image augmentation generated_images = self.augmenter(generated_images, training=True) # separate forward passes for the real and generated images, meaning # that batch normalization is applied separately real_logits = self.discriminator(real_images, training=True) generated_logits = self.discriminator(generated_images, training=True) generator_loss, discriminator_loss = self.adversarial_loss( real_logits, generated_logits ) # calculate gradients and update weights generator_gradients = tape.gradient( generator_loss, self.generator.trainable_weights ) discriminator_gradients = tape.gradient( discriminator_loss, self.discriminator.trainable_weights ) self.generator_optimizer.apply_gradients( zip(generator_gradients, self.generator.trainable_weights) ) self.discriminator_optimizer.apply_gradients( zip(discriminator_gradients, self.discriminator.trainable_weights) ) # update the augmentation probability based on the discriminator's performance self.augmenter.update(real_logits) self.generator_loss_tracker.update_state(generator_loss) self.discriminator_loss_tracker.update_state(discriminator_loss) self.real_accuracy.update_state(1.0, step(real_logits)) self.generated_accuracy.update_state(0.0, step(generated_logits)) self.augmentation_probability_tracker.update_state(self.augmenter.probability) # track the exponential moving average of the generator's weights to decrease # variance in the generation quality for weight, ema_weight in zip( self.generator.weights, self.ema_generator.weights ): ema_weight.assign(ema * ema_weight + (1 - ema) * weight) # KID is not measured during the training phase for computational efficiency return {m.name: m.result() for m in self.metrics[:-1]} def test_step(self, real_images): generated_images = self.generate(batch_size, training=False) self.kid.update_state(real_images, generated_images) # only KID is measured during the evaluation phase for computational efficiency return {self.kid.name: self.kid.result()} def plot_images(self, epoch=None, logs=None, num_rows=3, num_cols=6, interval=5): # plot random generated images for visual evaluation of generation quality if epoch is None or (epoch + 1) % interval == 0: num_images = num_rows * num_cols generated_images = self.generate(num_images, training=False) plt.figure(figsize=(num_cols * 2.0, num_rows * 2.0)) for row in range(num_rows): for col in range(num_cols): index = row * num_cols + col plt.subplot(num_rows, num_cols, index + 1) plt.imshow(generated_images[index]) plt.axis(\"off\") plt.tight_layout() plt.show() plt.close() Training One can should see from the metrics during training, that if the real accuracy (discriminator's accuracy on real images) is below the target accuracy, the augmentation probability is increased, and vice versa. In my experience, during a healthy GAN training, the discriminator accuracy should stay in the 80-95% range. Below that, the discriminator is too weak, above that it is too strong. Note that we track the exponential moving average of the generator's weights, and use that for image generation and KID evaluation. # create and compile the model model = GAN_ADA() model.compile( generator_optimizer=keras.optimizers.Adam(learning_rate, beta_1), discriminator_optimizer=keras.optimizers.Adam(learning_rate, beta_1), ) # save the best model based on the validation KID metric checkpoint_path = \"gan_model\" checkpoint_callback = tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_path, save_weights_only=True, monitor=\"val_kid\", mode=\"min\", save_best_only=True, ) # run training and plot generated images periodically model.fit( train_dataset, epochs=num_epochs, validation_data=val_dataset, callbacks=[ keras.callbacks.LambdaCallback(on_epoch_end=model.plot_images), checkpoint_callback, ], ) Model: \"generator\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) [(None, 64)] 0 _________________________________________________________________ dense (Dense) (None, 2048) 131072 _________________________________________________________________ batch_normalization (BatchNo (None, 2048) 6144 _________________________________________________________________ re_lu (ReLU) (None, 2048) 0 _________________________________________________________________ reshape (Reshape) (None, 4, 4, 128) 0 _________________________________________________________________ conv2d_transpose (Conv2DTran (None, 8, 8, 128) 262144 _________________________________________________________________ batch_normalization_1 (Batch (None, 8, 8, 128) 384 _________________________________________________________________ re_lu_1 (ReLU) (None, 8, 8, 128) 0 _________________________________________________________________ conv2d_transpose_1 (Conv2DTr (None, 16, 16, 128) 262144 _________________________________________________________________ batch_normalization_2 (Batch (None, 16, 16, 128) 384 _________________________________________________________________ re_lu_2 (ReLU) (None, 16, 16, 128) 0 _________________________________________________________________ conv2d_transpose_2 (Conv2DTr (None, 32, 32, 128) 262144 _________________________________________________________________ batch_normalization_3 (Batch (None, 32, 32, 128) 384 _________________________________________________________________ re_lu_3 (ReLU) (None, 32, 32, 128) 0 _________________________________________________________________ conv2d_transpose_3 (Conv2DTr (None, 64, 64, 3) 6147 ================================================================= Total params: 930,947 Trainable params: 926,083 Non-trainable params: 4,864 _________________________________________________________________ Model: \"discriminator\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_3 (InputLayer) [(None, 64, 64, 3)] 0 _________________________________________________________________ conv2d (Conv2D) (None, 32, 32, 128) 6144 _________________________________________________________________ batch_normalization_4 (Batch (None, 32, 32, 128) 384 _________________________________________________________________ leaky_re_lu (LeakyReLU) (None, 32, 32, 128) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 16, 16, 128) 262144 _________________________________________________________________ batch_normalization_5 (Batch (None, 16, 16, 128) 384 _________________________________________________________________ leaky_re_lu_1 (LeakyReLU) (None, 16, 16, 128) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 8, 8, 128) 262144 _________________________________________________________________ batch_normalization_6 (Batch (None, 8, 8, 128) 384 _________________________________________________________________ leaky_re_lu_2 (LeakyReLU) (None, 8, 8, 128) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 4, 4, 128) 262144 _________________________________________________________________ batch_normalization_7 (Batch (None, 4, 4, 128) 384 _________________________________________________________________ leaky_re_lu_3 (LeakyReLU) (None, 4, 4, 128) 0 _________________________________________________________________ flatten (Flatten) (None, 2048) 0 _________________________________________________________________ dropout (Dropout) (None, 2048) 0 _________________________________________________________________ dense_1 (Dense) (None, 1) 2049 ================================================================= Total params: 796,161 Trainable params: 795,137 Non-trainable params: 1,024 _________________________________________________________________ Epoch 1/10 46/46 [==============================] - 36s 307ms/step - g_loss: 3.3293 - d_loss: 0.1576 - real_acc: 0.9387 - gen_acc: 0.9579 - aug_p: 0.0020 - val_kid: 9.0999 Epoch 2/10 46/46 [==============================] - 10s 215ms/step - g_loss: 4.9824 - d_loss: 0.0912 - real_acc: 0.9704 - gen_acc: 0.9798 - aug_p: 0.0077 - val_kid: 8.3523 Epoch 3/10 46/46 [==============================] - 10s 218ms/step - g_loss: 5.0587 - d_loss: 0.1248 - real_acc: 0.9530 - gen_acc: 0.9625 - aug_p: 0.0131 - val_kid: 6.8116 Epoch 4/10 46/46 [==============================] - 10s 221ms/step - g_loss: 4.2580 - d_loss: 0.1002 - real_acc: 0.9686 - gen_acc: 0.9740 - aug_p: 0.0179 - val_kid: 5.2327 Epoch 5/10 46/46 [==============================] - 10s 225ms/step - g_loss: 4.6022 - d_loss: 0.0847 - real_acc: 0.9655 - gen_acc: 0.9852 - aug_p: 0.0234 - val_kid: 3.9004 png Epoch 6/10 46/46 [==============================] - 10s 224ms/step - g_loss: 4.9362 - d_loss: 0.0671 - real_acc: 0.9791 - gen_acc: 0.9895 - aug_p: 0.0291 - val_kid: 6.6020 Epoch 7/10 46/46 [==============================] - 10s 222ms/step - g_loss: 4.4272 - d_loss: 0.1184 - real_acc: 0.9570 - gen_acc: 0.9657 - aug_p: 0.0345 - val_kid: 3.3644 Epoch 8/10 46/46 [==============================] - 10s 220ms/step - g_loss: 4.5060 - d_loss: 0.1635 - real_acc: 0.9421 - gen_acc: 0.9594 - aug_p: 0.0392 - val_kid: 3.1381 Epoch 9/10 46/46 [==============================] - 10s 219ms/step - g_loss: 3.8264 - d_loss: 0.1667 - real_acc: 0.9383 - gen_acc: 0.9484 - aug_p: 0.0433 - val_kid: 2.9423 Epoch 10/10 46/46 [==============================] - 10s 219ms/step - g_loss: 3.4063 - d_loss: 0.1757 - real_acc: 0.9314 - gen_acc: 0.9475 - aug_p: 0.0473 - val_kid: 2.9112 png Inference # load the best model and generate images model.load_weights(checkpoint_path) model.plot_images() png Results By running the training for 400 epochs (which takes 2-3 hours in a Colab notebook), one can get high quality image generations using this code example. The evolution of a random batch of images over a 400 epoch training (ema=0.999 for animation smoothness): birds evolution gif Latent-space interpolation between a batch of selected images: birds interpolation gif I also recommend trying out training on other datasets, such as CelebA for example. In my experience good results can be achieved without changing any hyperparameters (though discriminator augmentation might not be necessary). GAN tips and tricks My goal with this example was to find a good tradeoff between ease of implementation and generation quality for GANs. During preparation I have run numerous ablations using this repository. In this section I list the lessons learned and my recommendations in my subjective order of importance. I recommend checking out the DCGAN paper, this NeurIPS talk, and this large scale GAN study for others' takes on this subject. Architectural tips resolution: Training GANs at higher resolutions tends to get more difficult, I recommend experimenting at 32x32 or 64x64 resolutions initially. initialization: If you see strong colorful patterns early on in the training, the initalization might be the issue. Set the kernel_initializer parameters of layers to random normal, and decrease the standard deviation (recommended value: 0.02, following DCGAN) until the issue disappears. upsampling: There are two main methods for upsampling in the generator. Transposed convolution is faster, but can lead to checkerboard artifacts, which can be reduced by using a kernel size that is divisible with the stride (recommended kernel size is 4 for a stride of 2). Upsampling + standard convolution can have slightly lower quality, but checkerboard artifacts are not an issue. I recommend using nearest-neighbor interpolation over bilinear for it. batch normalization in discriminator: Sometimes has a high impact, I recommend trying out both ways. spectral normalization: A popular technique for training GANs, can help with stability. I recommend disabling batch normalization's learnable scale parameters along with it. residual connections: While residual discriminators behave similarly, residual generators are more difficult to train in my experience. They are however necessary for training large and deep architectures. I recommend starting with non-resiudal architectures. dropout: Using dropout before the last layer of the discriminator improves generation quality in my experience. Recommended dropout rate is below 0.5. leaky ReLU: Use leaky ReLU activations in the discriminator to make its gradients less sparse. Recommended slope/alpha is 0.2 following DCGAN. Algorithmic tips loss functions: Numerous losses have been proposed over the years for training GANs, promising improved performance and stability. I have implemented 5 of them in this repository, and my experience is in line with this GAN study: no loss seems to consistently outperform the default non-saturating GAN loss. I recommend using that as a default. Adam's beta_1 parameter: The beta_1 parameter in Adam can be interpreted as the momentum of mean gradient estimation. Using 0.5 or even 0.0 instead of the default 0.9 value was proposed in DCGAN and is important. This example would not work using its default value. separate batch normalization for generated and real images: The forward pass of the discriminator should be separate for the generated and real images. Doing otherwise can lead to artifacts (45 degree stripes in my case) and decreased performance. exponential moving average of generator's weights: This helps to reduce the variance of the KID measurement, and helps in averaging out the rapid color palette changes during training. different learning rate for generator and discriminator: If one has the resources, it can help to tune the learning rates of the two networks separately. A similar idea is to update either network's (usually the discriminator's) weights multiple times for each of the other network's updates. I recommend using the same learning rate of 2e-4 (Adam), following DCGAN for both networks, and only updating both of them once as a default. label noise: One-sided label smoothing (using less than 1.0 for real labels), or adding noise to the labels can regularize the discriminator not to get overconfident, however in my case they did not improve performance. adaptive data augmentation: Since it adds another dynamic component to the training process, disable it as a default, and only enable it when the other components already work well. Related works Other GAN-related Keras code examples: DCGAN + CelebA WGAN + FashionMNIST WGAN + Molecules ConditionalGAN + MNIST CycleGAN + Horse2Zebra StyleGAN Modern GAN architecture-lines: SAGAN, BigGAN ProgressiveGAN, StyleGAN, StyleGAN2, StyleGAN2-ADA, AliasFreeGAN Concurrent papers on discriminator data augmentation: 1, 2, 3 Recent literature overview on GANs: talk A simple DCGAN trained using fit() by overriding train_step on CelebA images. Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import numpy as np import matplotlib.pyplot as plt import os import gdown from zipfile import ZipFile Prepare CelebA data We'll use face images from the CelebA dataset, resized to 64x64. os.makedirs(\"celeba_gan\") url = \"https://drive.google.com/uc?id=1O7m1010EJjLE5QxLZiM9Fpjs7Oj6e684\" output = \"celeba_gan/data.zip\" gdown.download(url, output, quiet=True) with ZipFile(\"celeba_gan/data.zip\", \"r\") as zipobj: zipobj.extractall(\"celeba_gan\") Create a dataset from our folder, and rescale the images to the [0-1] range: dataset = keras.preprocessing.image_dataset_from_directory( \"celeba_gan\", label_mode=None, image_size=(64, 64), batch_size=32 ) dataset = dataset.map(lambda x: x / 255.0) Found 202599 files belonging to 1 classes. Let's display a sample image: for x in dataset: plt.axis(\"off\") plt.imshow((x.numpy() * 255).astype(\"int32\")[0]) break png Create the discriminator It maps a 64x64 image to a binary classification score. discriminator = keras.Sequential( [ keras.Input(shape=(64, 64, 3)), layers.Conv2D(64, kernel_size=4, strides=2, padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(128, kernel_size=4, strides=2, padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(128, kernel_size=4, strides=2, padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Flatten(), layers.Dropout(0.2), layers.Dense(1, activation=\"sigmoid\"), ], name=\"discriminator\", ) discriminator.summary() Model: \"discriminator\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 32, 32, 64) 3136 _________________________________________________________________ leaky_re_lu (LeakyReLU) (None, 32, 32, 64) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 16, 16, 128) 131200 _________________________________________________________________ leaky_re_lu_1 (LeakyReLU) (None, 16, 16, 128) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 8, 8, 128) 262272 _________________________________________________________________ leaky_re_lu_2 (LeakyReLU) (None, 8, 8, 128) 0 _________________________________________________________________ flatten (Flatten) (None, 8192) 0 _________________________________________________________________ dropout (Dropout) (None, 8192) 0 _________________________________________________________________ dense (Dense) (None, 1) 8193 ================================================================= Total params: 404,801 Trainable params: 404,801 Non-trainable params: 0 _________________________________________________________________ Create the generator It mirrors the discriminator, replacing Conv2D layers with Conv2DTranspose layers. latent_dim = 128 generator = keras.Sequential( [ keras.Input(shape=(latent_dim,)), layers.Dense(8 * 8 * 128), layers.Reshape((8, 8, 128)), layers.Conv2DTranspose(128, kernel_size=4, strides=2, padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2DTranspose(256, kernel_size=4, strides=2, padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2DTranspose(512, kernel_size=4, strides=2, padding=\"same\"), layers.LeakyReLU(alpha=0.2), layers.Conv2D(3, kernel_size=5, padding=\"same\", activation=\"sigmoid\"), ], name=\"generator\", ) generator.summary() Model: \"generator\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_1 (Dense) (None, 8192) 1056768 _________________________________________________________________ reshape (Reshape) (None, 8, 8, 128) 0 _________________________________________________________________ conv2d_transpose (Conv2DTran (None, 16, 16, 128) 262272 _________________________________________________________________ leaky_re_lu_3 (LeakyReLU) (None, 16, 16, 128) 0 _________________________________________________________________ conv2d_transpose_1 (Conv2DTr (None, 32, 32, 256) 524544 _________________________________________________________________ leaky_re_lu_4 (LeakyReLU) (None, 32, 32, 256) 0 _________________________________________________________________ conv2d_transpose_2 (Conv2DTr (None, 64, 64, 512) 2097664 _________________________________________________________________ leaky_re_lu_5 (LeakyReLU) (None, 64, 64, 512) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 64, 64, 3) 38403 ================================================================= Total params: 3,979,651 Trainable params: 3,979,651 Non-trainable params: 0 _________________________________________________________________ Override train_step class GAN(keras.Model): def __init__(self, discriminator, generator, latent_dim): super(GAN, self).__init__() self.discriminator = discriminator self.generator = generator self.latent_dim = latent_dim def compile(self, d_optimizer, g_optimizer, loss_fn): super(GAN, self).compile() self.d_optimizer = d_optimizer self.g_optimizer = g_optimizer self.loss_fn = loss_fn self.d_loss_metric = keras.metrics.Mean(name=\"d_loss\") self.g_loss_metric = keras.metrics.Mean(name=\"g_loss\") @property def metrics(self): return [self.d_loss_metric, self.g_loss_metric] def train_step(self, real_images): # Sample random points in the latent space batch_size = tf.shape(real_images)[0] random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim)) # Decode them to fake images generated_images = self.generator(random_latent_vectors) # Combine them with real images combined_images = tf.concat([generated_images, real_images], axis=0) # Assemble labels discriminating real from fake images labels = tf.concat( [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0 ) # Add random noise to the labels - important trick! labels += 0.05 * tf.random.uniform(tf.shape(labels)) # Train the discriminator with tf.GradientTape() as tape: predictions = self.discriminator(combined_images) d_loss = self.loss_fn(labels, predictions) grads = tape.gradient(d_loss, self.discriminator.trainable_weights) self.d_optimizer.apply_gradients( zip(grads, self.discriminator.trainable_weights) ) # Sample random points in the latent space random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim)) # Assemble labels that say \"all real images\" misleading_labels = tf.zeros((batch_size, 1)) # Train the generator (note that we should *not* update the weights # of the discriminator)! with tf.GradientTape() as tape: predictions = self.discriminator(self.generator(random_latent_vectors)) g_loss = self.loss_fn(misleading_labels, predictions) grads = tape.gradient(g_loss, self.generator.trainable_weights) self.g_optimizer.apply_gradients(zip(grads, self.generator.trainable_weights)) # Update metrics self.d_loss_metric.update_state(d_loss) self.g_loss_metric.update_state(g_loss) return { \"d_loss\": self.d_loss_metric.result(), \"g_loss\": self.g_loss_metric.result(), } Create a callback that periodically saves generated images class GANMonitor(keras.callbacks.Callback): def __init__(self, num_img=3, latent_dim=128): self.num_img = num_img self.latent_dim = latent_dim def on_epoch_end(self, epoch, logs=None): random_latent_vectors = tf.random.normal(shape=(self.num_img, self.latent_dim)) generated_images = self.model.generator(random_latent_vectors) generated_images *= 255 generated_images.numpy() for i in range(self.num_img): img = keras.preprocessing.image.array_to_img(generated_images[i]) img.save(\"generated_img_%03d_%d.png\" % (epoch, i)) Train the end-to-end model epochs = 1 # In practice, use ~100 epochs gan = GAN(discriminator=discriminator, generator=generator, latent_dim=latent_dim) gan.compile( d_optimizer=keras.optimizers.Adam(learning_rate=0.0001), g_optimizer=keras.optimizers.Adam(learning_rate=0.0001), loss_fn=keras.losses.BinaryCrossentropy(), ) gan.fit( dataset, epochs=epochs, callbacks=[GANMonitor(num_img=10, latent_dim=latent_dim)] ) 6332/6332 [==============================] - 605s 96ms/step - d_loss: 0.6113 - g_loss: 1.1976 Some of the last generated images around epoch 30 (results keep improving after that): results Generating Deep Dreams with Keras. Introduction \"Deep dream\" is an image-filtering technique which consists of taking an image classification model, and running gradient ascent over an input image to try to maximize the activations of specific layers (and sometimes, specific units in specific layers) for this input. It produces hallucination-like visuals. It was first introduced by Alexander Mordvintsev from Google in July 2015. Process: Load the original image. Define a number of processing scales (\"octaves\"), from smallest to largest. Resize the original image to the smallest scale. For every scale, starting with the smallest (i.e. current one): - Run gradient ascent - Upscale image to the next scale - Reinject the detail that was lost at upscaling time Stop when we are back to the original size. To obtain the detail lost during upscaling, we simply take the original image, shrink it down, upscale it, and compare the result to the (resized) original image. Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras.applications import inception_v3 base_image_path = keras.utils.get_file(\"sky.jpg\", \"https://i.imgur.com/aGBdQyK.jpg\") result_prefix = \"sky_dream\" # These are the names of the layers # for which we try to maximize activation, # as well as their weight in the final loss # we try to maximize. # You can tweak these setting to obtain new visual effects. layer_settings = { \"mixed4\": 1.0, \"mixed5\": 1.5, \"mixed6\": 2.0, \"mixed7\": 2.5, } # Playing with these hyperparameters will also allow you to achieve new effects step = 0.01 # Gradient ascent step size num_octave = 3 # Number of scales at which to run gradient ascent octave_scale = 1.4 # Size ratio between scales iterations = 20 # Number of ascent steps per scale max_loss = 15.0 This is our base image: from IPython.display import Image, display display(Image(base_image_path)) jpeg Let's set up some image preprocessing/deprocessing utilities: def preprocess_image(image_path): # Util function to open, resize and format pictures # into appropriate arrays. img = keras.preprocessing.image.load_img(image_path) img = keras.preprocessing.image.img_to_array(img) img = np.expand_dims(img, axis=0) img = inception_v3.preprocess_input(img) return img def deprocess_image(x): # Util function to convert a NumPy array into a valid image. x = x.reshape((x.shape[1], x.shape[2], 3)) # Undo inception v3 preprocessing x /= 2.0 x += 0.5 x *= 255.0 # Convert to uint8 and clip to the valid range [0, 255] x = np.clip(x, 0, 255).astype(\"uint8\") return x Compute the Deep Dream loss First, build a feature extraction model to retrieve the activations of our target layers given an input image. # Build an InceptionV3 model loaded with pre-trained ImageNet weights model = inception_v3.InceptionV3(weights=\"imagenet\", include_top=False) # Get the symbolic outputs of each \"key\" layer (we gave them unique names). outputs_dict = dict( [ (layer.name, layer.output) for layer in [model.get_layer(name) for name in layer_settings.keys()] ] ) # Set up a model that returns the activation values for every target layer # (as a dict) feature_extractor = keras.Model(inputs=model.inputs, outputs=outputs_dict) The actual loss computation is very simple: def compute_loss(input_image): features = feature_extractor(input_image) # Initialize the loss loss = tf.zeros(shape=()) for name in features.keys(): coeff = layer_settings[name] activation = features[name] # We avoid border artifacts by only involving non-border pixels in the loss. scaling = tf.reduce_prod(tf.cast(tf.shape(activation), \"float32\")) loss += coeff * tf.reduce_sum(tf.square(activation[:, 2:-2, 2:-2, :])) / scaling return loss Set up the gradient ascent loop for one octave @tf.function def gradient_ascent_step(img, learning_rate): with tf.GradientTape() as tape: tape.watch(img) loss = compute_loss(img) # Compute gradients. grads = tape.gradient(loss, img) # Normalize gradients. grads /= tf.maximum(tf.reduce_mean(tf.abs(grads)), 1e-6) img += learning_rate * grads return loss, img def gradient_ascent_loop(img, iterations, learning_rate, max_loss=None): for i in range(iterations): loss, img = gradient_ascent_step(img, learning_rate) if max_loss is not None and loss > max_loss: break print(\"... Loss value at step %d: %.2f\" % (i, loss)) return img Run the training loop, iterating over different octaves original_img = preprocess_image(base_image_path) original_shape = original_img.shape[1:3] successive_shapes = [original_shape] for i in range(1, num_octave): shape = tuple([int(dim / (octave_scale ** i)) for dim in original_shape]) successive_shapes.append(shape) successive_shapes = successive_shapes[::-1] shrunk_original_img = tf.image.resize(original_img, successive_shapes[0]) img = tf.identity(original_img) # Make a copy for i, shape in enumerate(successive_shapes): print(\"Processing octave %d with shape %s\" % (i, shape)) img = tf.image.resize(img, shape) img = gradient_ascent_loop( img, iterations=iterations, learning_rate=step, max_loss=max_loss ) upscaled_shrunk_original_img = tf.image.resize(shrunk_original_img, shape) same_size_original = tf.image.resize(original_img, shape) lost_detail = same_size_original - upscaled_shrunk_original_img img += lost_detail shrunk_original_img = tf.image.resize(original_img, shape) keras.preprocessing.image.save_img(result_prefix + \".png\", deprocess_image(img.numpy())) Processing octave 0 with shape (326, 489) ... Loss value at step 0: 0.44 ... Loss value at step 1: 0.62 ... Loss value at step 2: 0.90 ... Loss value at step 3: 1.25 ... Loss value at step 4: 1.57 ... Loss value at step 5: 1.92 ... Loss value at step 6: 2.20 ... Loss value at step 7: 2.52 ... Loss value at step 8: 2.82 ... Loss value at step 9: 3.11 ... Loss value at step 10: 3.39 ... Loss value at step 11: 3.67 ... Loss value at step 12: 3.93 ... Loss value at step 13: 4.19 ... Loss value at step 14: 4.42 ... Loss value at step 15: 4.69 ... Loss value at step 16: 4.93 ... Loss value at step 17: 5.18 ... Loss value at step 18: 5.47 ... Loss value at step 19: 5.70 Processing octave 1 with shape (457, 685) ... Loss value at step 0: 1.08 ... Loss value at step 1: 1.74 ... Loss value at step 2: 2.30 ... Loss value at step 3: 2.79 ... Loss value at step 4: 3.21 ... Loss value at step 5: 3.64 ... Loss value at step 6: 4.04 ... Loss value at step 7: 4.42 ... Loss value at step 8: 4.78 ... Loss value at step 9: 5.13 ... Loss value at step 10: 5.49 ... Loss value at step 11: 5.82 ... Loss value at step 12: 6.14 ... Loss value at step 13: 6.43 ... Loss value at step 14: 6.78 ... Loss value at step 15: 7.07 ... Loss value at step 16: 7.36 ... Loss value at step 17: 7.64 ... Loss value at step 18: 7.94 ... Loss value at step 19: 8.21 Processing octave 2 with shape (640, 960) ... Loss value at step 0: 1.25 ... Loss value at step 1: 2.02 ... Loss value at step 2: 2.65 ... Loss value at step 3: 3.18 ... Loss value at step 4: 3.68 ... Loss value at step 5: 4.18 ... Loss value at step 6: 4.63 ... Loss value at step 7: 5.09 ... Loss value at step 8: 5.49 ... Loss value at step 9: 5.90 ... Loss value at step 10: 6.24 ... Loss value at step 11: 6.57 ... Loss value at step 12: 6.84 ... Loss value at step 13: 7.21 ... Loss value at step 14: 7.59 ... Loss value at step 15: 7.89 ... Loss value at step 16: 8.18 ... Loss value at step 17: 8.55 ... Loss value at step 18: 8.84 ... Loss value at step 19: 9.13 Display the result. display(Image(result_prefix + \".png\")) pngpng Estimating the density distribution of the 'double moon' dataset. Introduction The aim of this work is to map a simple distribution - which is easy to sample and whose density is simple to estimate - to a more complex one learned from the data. This kind of generative model is also known as \"normalizing flow\". In order to do this, the model is trained via the maximum likelihood principle, using the \"change of variable\" formula. We will use an affine coupling function. We create it such that its inverse, as well as the determinant of the Jacobian, are easy to obtain (more details in the referenced paper). Requirements: Tensorflow 2.3 Tensorflow probability 0.11.0 Reference: Density estimation using Real NVP Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras import regularizers from sklearn.datasets import make_moons import numpy as np import matplotlib.pyplot as plt import tensorflow_probability as tfp Load the data data = make_moons(3000, noise=0.05)[0].astype(\"float32\") norm = layers.Normalization() norm.adapt(data) normalized_data = norm(data) Affine coupling layer # Creating a custom layer with keras API. output_dim = 256 reg = 0.01 def Coupling(input_shape): input = keras.layers.Input(shape=input_shape) t_layer_1 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(input) t_layer_2 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(t_layer_1) t_layer_3 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(t_layer_2) t_layer_4 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(t_layer_3) t_layer_5 = keras.layers.Dense( input_shape, activation=\"linear\", kernel_regularizer=regularizers.l2(reg) )(t_layer_4) s_layer_1 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(input) s_layer_2 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(s_layer_1) s_layer_3 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(s_layer_2) s_layer_4 = keras.layers.Dense( output_dim, activation=\"relu\", kernel_regularizer=regularizers.l2(reg) )(s_layer_3) s_layer_5 = keras.layers.Dense( input_shape, activation=\"tanh\", kernel_regularizer=regularizers.l2(reg) )(s_layer_4) return keras.Model(inputs=input, outputs=[s_layer_5, t_layer_5]) Real NVP class RealNVP(keras.Model): def __init__(self, num_coupling_layers): super(RealNVP, self).__init__() self.num_coupling_layers = num_coupling_layers # Distribution of the latent space. self.distribution = tfp.distributions.MultivariateNormalDiag( loc=[0.0, 0.0], scale_diag=[1.0, 1.0] ) self.masks = np.array( [[0, 1], [1, 0]] * (num_coupling_layers // 2), dtype=\"float32\" ) self.loss_tracker = keras.metrics.Mean(name=\"loss\") self.layers_list = [Coupling(2) for i in range(num_coupling_layers)] @property def metrics(self): \"\"\"List of the model's metrics. We make sure the loss tracker is listed as part of `model.metrics` so that `fit()` and `evaluate()` are able to `reset()` the loss tracker at the start of each epoch and at the start of an `evaluate()` call. \"\"\" return [self.loss_tracker] def call(self, x, training=True): log_det_inv = 0 direction = 1 if training: direction = -1 for i in range(self.num_coupling_layers)[::direction]: x_masked = x * self.masks[i] reversed_mask = 1 - self.masks[i] s, t = self.layers_list[i](x_masked) s *= reversed_mask t *= reversed_mask gate = (direction - 1) / 2 x = ( reversed_mask * (x * tf.exp(direction * s) + direction * t * tf.exp(gate * s)) + x_masked ) log_det_inv += gate * tf.reduce_sum(s, [1]) return x, log_det_inv # Log likelihood of the normal distribution plus the log determinant of the jacobian. def log_loss(self, x): y, logdet = self(x) log_likelihood = self.distribution.log_prob(y) + logdet return -tf.reduce_mean(log_likelihood) def train_step(self, data): with tf.GradientTape() as tape: loss = self.log_loss(data) g = tape.gradient(loss, self.trainable_variables) self.optimizer.apply_gradients(zip(g, self.trainable_variables)) self.loss_tracker.update_state(loss) return {\"loss\": self.loss_tracker.result()} def test_step(self, data): loss = self.log_loss(data) self.loss_tracker.update_state(loss) return {\"loss\": self.loss_tracker.result()} Model training model = RealNVP(num_coupling_layers=6) model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0001)) history = model.fit( normalized_data, batch_size=256, epochs=300, verbose=2, validation_split=0.2 ) Epoch 1/300 10/10 - 1s - loss: 2.7178 - val_loss: 2.5872 Epoch 2/300 10/10 - 0s - loss: 2.6151 - val_loss: 2.5421 Epoch 3/300 10/10 - 0s - loss: 2.5702 - val_loss: 2.5001 Epoch 4/300 10/10 - 0s - loss: 2.5241 - val_loss: 2.4650 Epoch 5/300 10/10 - 0s - loss: 2.4934 - val_loss: 2.4377 Epoch 6/300 10/10 - 0s - loss: 2.4684 - val_loss: 2.4236 Epoch 7/300 10/10 - 0s - loss: 2.4420 - val_loss: 2.3976 Epoch 8/300 10/10 - 0s - loss: 2.4185 - val_loss: 2.3722 Epoch 9/300 10/10 - 0s - loss: 2.3857 - val_loss: 2.3591 Epoch 10/300 10/10 - 0s - loss: 2.3611 - val_loss: 2.3341 Epoch 11/300 10/10 - 0s - loss: 2.3323 - val_loss: 2.2999 Epoch 12/300 10/10 - 0s - loss: 2.3035 - val_loss: 2.2688 Epoch 13/300 10/10 - 0s - loss: 2.2694 - val_loss: 2.2435 Epoch 14/300 10/10 - 0s - loss: 2.2359 - val_loss: 2.2137 Epoch 15/300 10/10 - 0s - loss: 2.2053 - val_loss: 2.1877 Epoch 16/300 10/10 - 0s - loss: 2.1775 - val_loss: 2.1626 Epoch 17/300 10/10 - 0s - loss: 2.1546 - val_loss: 2.1257 Epoch 18/300 10/10 - 0s - loss: 2.1310 - val_loss: 2.1022 Epoch 19/300 10/10 - 0s - loss: 2.1258 - val_loss: 2.1022 Epoch 20/300 10/10 - 0s - loss: 2.1097 - val_loss: 2.0670 Epoch 21/300 10/10 - 0s - loss: 2.0811 - val_loss: 2.0502 Epoch 22/300 10/10 - 0s - loss: 2.0407 - val_loss: 2.0235 Epoch 23/300 10/10 - 0s - loss: 2.0169 - val_loss: 1.9946 Epoch 24/300 10/10 - 0s - loss: 2.0011 - val_loss: 1.9843 Epoch 25/300 10/10 - 0s - loss: 2.0151 - val_loss: 1.9728 Epoch 26/300 10/10 - 0s - loss: 1.9427 - val_loss: 1.9473 Epoch 27/300 10/10 - 0s - loss: 1.9266 - val_loss: 1.9245 Epoch 28/300 10/10 - 0s - loss: 1.8574 - val_loss: 1.7811 Epoch 29/300 10/10 - 0s - loss: 1.7765 - val_loss: 1.7016 Epoch 30/300 10/10 - 0s - loss: 1.7020 - val_loss: 1.6801 Epoch 31/300 10/10 - 0s - loss: 1.6935 - val_loss: 1.6644 Epoch 32/300 10/10 - 0s - loss: 1.6643 - val_loss: 1.6998 Epoch 33/300 10/10 - 0s - loss: 1.6733 - val_loss: 1.7054 Epoch 34/300 10/10 - 0s - loss: 1.6405 - val_loss: 1.6217 Epoch 35/300 10/10 - 0s - loss: 1.6035 - val_loss: 1.6094 Epoch 36/300 10/10 - 0s - loss: 1.5700 - val_loss: 1.6086 Epoch 37/300 10/10 - 0s - loss: 1.5750 - val_loss: 1.6160 Epoch 38/300 10/10 - 0s - loss: 1.5512 - val_loss: 1.6023 Epoch 39/300 10/10 - 0s - loss: 1.5664 - val_loss: 1.5859 Epoch 40/300 10/10 - 0s - loss: 1.5949 - val_loss: 1.6684 Epoch 41/300 10/10 - 0s - loss: 1.6125 - val_loss: 1.5688 Epoch 42/300 10/10 - 0s - loss: 1.5855 - val_loss: 1.5783 Epoch 43/300 10/10 - 0s - loss: 1.5394 - val_loss: 1.5332 Epoch 44/300 10/10 - 0s - loss: 1.5093 - val_loss: 1.6073 Epoch 45/300 10/10 - 0s - loss: 1.5417 - val_loss: 1.5910 Epoch 46/300 10/10 - 0s - loss: 1.5095 - val_loss: 1.5061 Epoch 47/300 10/10 - 0s - loss: 1.4626 - val_loss: 1.5143 Epoch 48/300 10/10 - 0s - loss: 1.4588 - val_loss: 1.5005 Epoch 49/300 10/10 - 0s - loss: 1.4683 - val_loss: 1.5071 Epoch 50/300 10/10 - 0s - loss: 1.4285 - val_loss: 1.5894 Epoch 51/300 10/10 - 0s - loss: 1.4110 - val_loss: 1.4964 Epoch 52/300 10/10 - 0s - loss: 1.4510 - val_loss: 1.5608 Epoch 53/300 10/10 - 0s - loss: 1.4584 - val_loss: 1.5640 Epoch 54/300 10/10 - 0s - loss: 1.4393 - val_loss: 1.5073 Epoch 55/300 10/10 - 0s - loss: 1.4248 - val_loss: 1.5284 Epoch 56/300 10/10 - 0s - loss: 1.4659 - val_loss: 1.4654 Epoch 57/300 10/10 - 0s - loss: 1.4572 - val_loss: 1.4633 Epoch 58/300 10/10 - 0s - loss: 1.4254 - val_loss: 1.4536 Epoch 59/300 10/10 - 0s - loss: 1.3927 - val_loss: 1.4672 Epoch 60/300 10/10 - 0s - loss: 1.3782 - val_loss: 1.4166 Epoch 61/300 10/10 - 0s - loss: 1.3674 - val_loss: 1.4340 Epoch 62/300 10/10 - 0s - loss: 1.3521 - val_loss: 1.4302 Epoch 63/300 10/10 - 0s - loss: 1.3656 - val_loss: 1.4610 Epoch 64/300 10/10 - 0s - loss: 1.3916 - val_loss: 1.5597 Epoch 65/300 10/10 - 0s - loss: 1.4478 - val_loss: 1.4781 Epoch 66/300 10/10 - 0s - loss: 1.3987 - val_loss: 1.5077 Epoch 67/300 10/10 - 0s - loss: 1.3553 - val_loss: 1.4511 Epoch 68/300 10/10 - 0s - loss: 1.3901 - val_loss: 1.4013 Epoch 69/300 10/10 - 0s - loss: 1.3682 - val_loss: 1.4378 Epoch 70/300 10/10 - 0s - loss: 1.3688 - val_loss: 1.4445 Epoch 71/300 10/10 - 0s - loss: 1.3341 - val_loss: 1.4139 Epoch 72/300 10/10 - 0s - loss: 1.3621 - val_loss: 1.5097 Epoch 73/300 10/10 - 0s - loss: 1.4158 - val_loss: 1.4735 Epoch 74/300 10/10 - 0s - loss: 1.4013 - val_loss: 1.4390 Epoch 75/300 10/10 - 0s - loss: 1.3637 - val_loss: 1.4306 Epoch 76/300 10/10 - 0s - loss: 1.3278 - val_loss: 1.4007 Epoch 77/300 10/10 - 0s - loss: 1.3153 - val_loss: 1.4226 Epoch 78/300 10/10 - 0s - loss: 1.3687 - val_loss: 1.4315 Epoch 79/300 10/10 - 0s - loss: 1.3377 - val_loss: 1.4520 Epoch 80/300 10/10 - 0s - loss: 1.3214 - val_loss: 1.4643 Epoch 81/300 10/10 - 0s - loss: 1.2906 - val_loss: 1.5738 Epoch 82/300 10/10 - 0s - loss: 1.3231 - val_loss: 1.8303 Epoch 83/300 10/10 - 0s - loss: 1.3099 - val_loss: 1.4406 Epoch 84/300 10/10 - 0s - loss: 1.3427 - val_loss: 1.5539 Epoch 85/300 10/10 - 0s - loss: 1.3270 - val_loss: 1.5454 Epoch 86/300 10/10 - 0s - loss: 1.3959 - val_loss: 1.4328 Epoch 87/300 10/10 - 0s - loss: 1.3469 - val_loss: 1.4087 Epoch 88/300 10/10 - 0s - loss: 1.3383 - val_loss: 1.4003 Epoch 89/300 10/10 - 0s - loss: 1.2968 - val_loss: 1.4284 Epoch 90/300 10/10 - 0s - loss: 1.4229 - val_loss: 1.4831 Epoch 91/300 10/10 - 0s - loss: 1.4664 - val_loss: 1.4332 Epoch 92/300 10/10 - 0s - loss: 1.4076 - val_loss: 1.4708 Epoch 93/300 10/10 - 0s - loss: 1.3508 - val_loss: 1.3865 Epoch 94/300 10/10 - 0s - loss: 1.3170 - val_loss: 1.3794 Epoch 95/300 10/10 - 0s - loss: 1.3266 - val_loss: 1.5315 Epoch 96/300 10/10 - 0s - loss: 1.3247 - val_loss: 1.4001 Epoch 97/300 10/10 - 0s - loss: 1.2963 - val_loss: 1.4036 Epoch 98/300 10/10 - 0s - loss: 1.2839 - val_loss: 1.4195 Epoch 99/300 10/10 - 0s - loss: 1.3517 - val_loss: 1.4023 Epoch 100/300 10/10 - 0s - loss: 1.3468 - val_loss: 1.4460 Epoch 101/300 10/10 - 0s - loss: 1.3938 - val_loss: 1.4292 Epoch 102/300 10/10 - 0s - loss: 1.3313 - val_loss: 1.4288 Epoch 103/300 10/10 - 0s - loss: 1.3267 - val_loss: 1.3968 Epoch 104/300 10/10 - 0s - loss: 1.3321 - val_loss: 1.4145 Epoch 105/300 10/10 - 0s - loss: 1.2973 - val_loss: 1.3500 Epoch 106/300 10/10 - 0s - loss: 1.2455 - val_loss: 1.4672 Epoch 107/300 10/10 - 0s - loss: 1.3255 - val_loss: 1.4633 Epoch 108/300 10/10 - 0s - loss: 1.3379 - val_loss: 1.3717 Epoch 109/300 10/10 - 0s - loss: 1.3243 - val_loss: 1.4118 Epoch 110/300 10/10 - 0s - loss: 1.3184 - val_loss: 1.3922 Epoch 111/300 10/10 - 0s - loss: 1.2779 - val_loss: 1.3783 Epoch 112/300 10/10 - 0s - loss: 1.3495 - val_loss: 1.6651 Epoch 113/300 10/10 - 0s - loss: 1.5595 - val_loss: 1.5984 Epoch 114/300 10/10 - 0s - loss: 1.4541 - val_loss: 1.4844 Epoch 115/300 10/10 - 0s - loss: 1.4001 - val_loss: 1.4477 Epoch 116/300 10/10 - 0s - loss: 1.3305 - val_loss: 1.4097 Epoch 117/300 10/10 - 0s - loss: 1.3084 - val_loss: 1.3643 Epoch 118/300 10/10 - 0s - loss: 1.2993 - val_loss: 1.3726 Epoch 119/300 10/10 - 0s - loss: 1.2624 - val_loss: 1.3927 Epoch 120/300 10/10 - 0s - loss: 1.3288 - val_loss: 1.3912 Epoch 121/300 10/10 - 0s - loss: 1.2925 - val_loss: 1.3809 Epoch 122/300 10/10 - 0s - loss: 1.2756 - val_loss: 1.3434 Epoch 123/300 10/10 - 0s - loss: 1.2540 - val_loss: 1.3699 Epoch 124/300 10/10 - 0s - loss: 1.3008 - val_loss: 1.3272 Epoch 125/300 10/10 - 0s - loss: 1.2932 - val_loss: 1.3365 Epoch 126/300 10/10 - 0s - loss: 1.2844 - val_loss: 1.3824 Epoch 127/300 10/10 - 0s - loss: 1.2688 - val_loss: 1.3413 Epoch 128/300 10/10 - 0s - loss: 1.2636 - val_loss: 1.3659 Epoch 129/300 10/10 - 0s - loss: 1.2590 - val_loss: 1.3724 Epoch 130/300 10/10 - 0s - loss: 1.4471 - val_loss: 1.4119 Epoch 131/300 10/10 - 0s - loss: 1.5125 - val_loss: 1.5486 Epoch 132/300 10/10 - 0s - loss: 1.5826 - val_loss: 1.4578 Epoch 133/300 10/10 - 0s - loss: 1.4168 - val_loss: 1.4405 Epoch 134/300 10/10 - 0s - loss: 1.3739 - val_loss: 1.4728 Epoch 135/300 10/10 - 0s - loss: 1.3304 - val_loss: 1.3734 Epoch 136/300 10/10 - 0s - loss: 1.2987 - val_loss: 1.3769 Epoch 137/300 10/10 - 0s - loss: 1.2883 - val_loss: 1.3542 Epoch 138/300 10/10 - 0s - loss: 1.2805 - val_loss: 1.4974 Epoch 139/300 10/10 - 0s - loss: 1.3558 - val_loss: 1.3958 Epoch 140/300 10/10 - 0s - loss: 1.3244 - val_loss: 1.3705 Epoch 141/300 10/10 - 0s - loss: 1.3043 - val_loss: 1.3563 Epoch 142/300 10/10 - 0s - loss: 1.3302 - val_loss: 1.3611 Epoch 143/300 10/10 - 0s - loss: 1.3188 - val_loss: 1.4500 Epoch 144/300 10/10 - 0s - loss: 1.3100 - val_loss: 1.3893 Epoch 145/300 10/10 - 0s - loss: 1.2864 - val_loss: 1.3436 Epoch 146/300 10/10 - 0s - loss: 1.3013 - val_loss: 1.3548 Epoch 147/300 10/10 - 0s - loss: 1.2672 - val_loss: 1.4179 Epoch 148/300 10/10 - 0s - loss: 1.2650 - val_loss: 1.3705 Epoch 149/300 10/10 - 0s - loss: 1.2931 - val_loss: 1.3274 Epoch 150/300 10/10 - 0s - loss: 1.3365 - val_loss: 1.4164 Epoch 151/300 10/10 - 0s - loss: 1.3562 - val_loss: 1.3815 Epoch 152/300 10/10 - 0s - loss: 1.3067 - val_loss: 1.4100 Epoch 153/300 10/10 - 0s - loss: 1.2752 - val_loss: 1.3928 Epoch 154/300 10/10 - 0s - loss: 1.2659 - val_loss: 1.3512 Epoch 155/300 10/10 - 0s - loss: 1.2696 - val_loss: 1.3715 Epoch 156/300 10/10 - 0s - loss: 1.2719 - val_loss: 1.3366 Epoch 157/300 10/10 - 0s - loss: 1.2718 - val_loss: 1.5284 Epoch 158/300 10/10 - 0s - loss: 1.3099 - val_loss: 1.3342 Epoch 159/300 10/10 - 0s - loss: 1.2655 - val_loss: 1.3692 Epoch 160/300 10/10 - 0s - loss: 1.2694 - val_loss: 1.5034 Epoch 161/300 10/10 - 0s - loss: 1.3370 - val_loss: 1.3611 Epoch 162/300 10/10 - 0s - loss: 1.2799 - val_loss: 1.3745 Epoch 163/300 10/10 - 0s - loss: 1.2714 - val_loss: 1.3639 Epoch 164/300 10/10 - 0s - loss: 1.2711 - val_loss: 1.3178 Epoch 165/300 10/10 - 0s - loss: 1.2754 - val_loss: 1.3722 Epoch 166/300 10/10 - 0s - loss: 1.2515 - val_loss: 1.3407 Epoch 167/300 10/10 - 0s - loss: 1.2431 - val_loss: 1.4075 Epoch 168/300 10/10 - 0s - loss: 1.2534 - val_loss: 1.3128 Epoch 169/300 10/10 - 0s - loss: 1.2159 - val_loss: 1.3614 Epoch 170/300 10/10 - 0s - loss: 1.2591 - val_loss: 1.3247 Epoch 171/300 10/10 - 0s - loss: 1.2424 - val_loss: 1.3186 Epoch 172/300 10/10 - 0s - loss: 1.2218 - val_loss: 1.3259 Epoch 173/300 10/10 - 0s - loss: 1.2328 - val_loss: 1.3401 Epoch 174/300 10/10 - 0s - loss: 1.2168 - val_loss: 1.3092 Epoch 175/300 10/10 - 0s - loss: 1.2779 - val_loss: 1.3349 Epoch 176/300 10/10 - 0s - loss: 1.2560 - val_loss: 1.3331 Epoch 177/300 10/10 - 0s - loss: 1.2445 - val_loss: 1.3119 Epoch 178/300 10/10 - 0s - loss: 1.2250 - val_loss: 1.3168 Epoch 179/300 10/10 - 0s - loss: 1.2139 - val_loss: 1.3217 Epoch 180/300 10/10 - 0s - loss: 1.2020 - val_loss: 1.2753 Epoch 181/300 10/10 - 0s - loss: 1.1906 - val_loss: 1.2765 Epoch 182/300 10/10 - 0s - loss: 1.2045 - val_loss: 1.2821 Epoch 183/300 10/10 - 0s - loss: 1.2229 - val_loss: 1.2810 Epoch 184/300 10/10 - 0s - loss: 1.1967 - val_loss: 1.3295 Epoch 185/300 10/10 - 0s - loss: 1.1852 - val_loss: 1.2866 Epoch 186/300 10/10 - 0s - loss: 1.1941 - val_loss: 1.3126 Epoch 187/300 10/10 - 0s - loss: 1.1783 - val_loss: 1.3282 Epoch 188/300 10/10 - 0s - loss: 1.1758 - val_loss: 1.2702 Epoch 189/300 10/10 - 0s - loss: 1.1763 - val_loss: 1.2694 Epoch 190/300 10/10 - 0s - loss: 1.1802 - val_loss: 1.3377 Epoch 191/300 10/10 - 0s - loss: 1.1989 - val_loss: 1.2996 Epoch 192/300 10/10 - 0s - loss: 1.1998 - val_loss: 1.2948 Epoch 193/300 10/10 - 0s - loss: 1.1977 - val_loss: 1.3324 Epoch 194/300 10/10 - 0s - loss: 1.1756 - val_loss: 1.3388 Epoch 195/300 10/10 - 0s - loss: 1.1738 - val_loss: 1.3121 Epoch 196/300 10/10 - 0s - loss: 1.1752 - val_loss: 1.2886 Epoch 197/300 10/10 - 0s - loss: 1.1894 - val_loss: 1.2996 Epoch 198/300 10/10 - 0s - loss: 1.1771 - val_loss: 1.2697 Epoch 199/300 10/10 - 0s - loss: 1.1741 - val_loss: 1.2830 Epoch 200/300 10/10 - 0s - loss: 1.1775 - val_loss: 1.3095 Epoch 201/300 10/10 - 0s - loss: 1.1814 - val_loss: 1.2873 Epoch 202/300 10/10 - 0s - loss: 1.1782 - val_loss: 1.2748 Epoch 203/300 10/10 - 0s - loss: 1.1623 - val_loss: 1.2861 Epoch 204/300 10/10 - 0s - loss: 1.1691 - val_loss: 1.2960 Epoch 205/300 10/10 - 0s - loss: 1.1722 - val_loss: 1.3015 Epoch 206/300 10/10 - 0s - loss: 1.2002 - val_loss: 1.2970 Epoch 207/300 10/10 - 0s - loss: 1.1916 - val_loss: 1.3317 Epoch 208/300 10/10 - 0s - loss: 1.1938 - val_loss: 1.3479 Epoch 209/300 10/10 - 0s - loss: 1.2207 - val_loss: 1.2718 Epoch 210/300 10/10 - 0s - loss: 1.1927 - val_loss: 1.2947 Epoch 211/300 10/10 - 0s - loss: 1.1799 - val_loss: 1.2910 Epoch 212/300 10/10 - 0s - loss: 1.1877 - val_loss: 1.3001 Epoch 213/300 10/10 - 0s - loss: 1.1671 - val_loss: 1.2740 Epoch 214/300 10/10 - 0s - loss: 1.2021 - val_loss: 1.3010 Epoch 215/300 10/10 - 0s - loss: 1.1937 - val_loss: 1.2906 Epoch 216/300 10/10 - 0s - loss: 1.1659 - val_loss: 1.2879 Epoch 217/300 10/10 - 0s - loss: 1.1914 - val_loss: 1.2839 Epoch 218/300 10/10 - 0s - loss: 1.1787 - val_loss: 1.2966 Epoch 219/300 10/10 - 0s - loss: 1.1651 - val_loss: 1.2927 Epoch 220/300 10/10 - 0s - loss: 1.1803 - val_loss: 1.2818 Epoch 221/300 10/10 - 0s - loss: 1.1701 - val_loss: 1.2787 Epoch 222/300 10/10 - 0s - loss: 1.2009 - val_loss: 1.3056 Epoch 223/300 10/10 - 0s - loss: 1.1741 - val_loss: 1.3055 Epoch 224/300 10/10 - 0s - loss: 1.1955 - val_loss: 1.3187 Epoch 225/300 10/10 - 0s - loss: 1.2137 - val_loss: 1.2908 Epoch 226/300 10/10 - 0s - loss: 1.1723 - val_loss: 1.2808 Epoch 227/300 10/10 - 0s - loss: 1.1682 - val_loss: 1.2974 Epoch 228/300 10/10 - 0s - loss: 1.1569 - val_loss: 1.3180 Epoch 229/300 10/10 - 0s - loss: 1.1848 - val_loss: 1.2840 Epoch 230/300 10/10 - 0s - loss: 1.1912 - val_loss: 1.2940 Epoch 231/300 10/10 - 0s - loss: 1.1633 - val_loss: 1.2905 Epoch 232/300 10/10 - 0s - loss: 1.1539 - val_loss: 1.2985 Epoch 233/300 10/10 - 0s - loss: 1.1574 - val_loss: 1.2750 Epoch 234/300 10/10 - 0s - loss: 1.1555 - val_loss: 1.2690 Epoch 235/300 10/10 - 0s - loss: 1.1519 - val_loss: 1.2961 Epoch 236/300 10/10 - 0s - loss: 1.1763 - val_loss: 1.2750 Epoch 237/300 10/10 - 0s - loss: 1.1670 - val_loss: 1.3295 Epoch 238/300 10/10 - 0s - loss: 1.1574 - val_loss: 1.2904 Epoch 239/300 10/10 - 0s - loss: 1.1588 - val_loss: 1.3034 Epoch 240/300 10/10 - 0s - loss: 1.1630 - val_loss: 1.2803 Epoch 241/300 10/10 - 0s - loss: 1.1688 - val_loss: 1.2860 Epoch 242/300 10/10 - 0s - loss: 1.1730 - val_loss: 1.3309 Epoch 243/300 10/10 - 0s - loss: 1.2057 - val_loss: 1.3330 Epoch 244/300 10/10 - 0s - loss: 1.1706 - val_loss: 1.3037 Epoch 245/300 10/10 - 0s - loss: 1.1526 - val_loss: 1.2910 Epoch 246/300 10/10 - 0s - loss: 1.1625 - val_loss: 1.2869 Epoch 247/300 10/10 - 0s - loss: 1.1555 - val_loss: 1.3253 Epoch 248/300 10/10 - 0s - loss: 1.1527 - val_loss: 1.3349 Epoch 249/300 10/10 - 0s - loss: 1.1544 - val_loss: 1.2894 Epoch 250/300 10/10 - 0s - loss: 1.1434 - val_loss: 1.2844 Epoch 251/300 10/10 - 0s - loss: 1.1479 - val_loss: 1.3500 Epoch 252/300 10/10 - 0s - loss: 1.1594 - val_loss: 1.3206 Epoch 253/300 10/10 - 0s - loss: 1.1975 - val_loss: 1.2897 Epoch 254/300 10/10 - 0s - loss: 1.1800 - val_loss: 1.2983 Epoch 255/300 10/10 - 0s - loss: 1.1656 - val_loss: 1.2979 Epoch 256/300 10/10 - 0s - loss: 1.1658 - val_loss: 1.3044 Epoch 257/300 10/10 - 0s - loss: 1.1665 - val_loss: 1.2955 Epoch 258/300 10/10 - 0s - loss: 1.1577 - val_loss: 1.2998 Epoch 259/300 10/10 - 0s - loss: 1.1625 - val_loss: 1.3247 Epoch 260/300 10/10 - 0s - loss: 1.1652 - val_loss: 1.3172 Epoch 261/300 10/10 - 0s - loss: 1.1551 - val_loss: 1.2899 Epoch 262/300 10/10 - 0s - loss: 1.1433 - val_loss: 1.2832 Epoch 263/300 10/10 - 0s - loss: 1.1498 - val_loss: 1.2781 Epoch 264/300 10/10 - 0s - loss: 1.1599 - val_loss: 1.3124 Epoch 265/300 10/10 - 0s - loss: 1.1693 - val_loss: 1.2873 Epoch 266/300 10/10 - 0s - loss: 1.1663 - val_loss: 1.2625 Epoch 267/300 10/10 - 0s - loss: 1.1706 - val_loss: 1.2935 Epoch 268/300 10/10 - 0s - loss: 1.1641 - val_loss: 1.2688 Epoch 269/300 10/10 - 0s - loss: 1.1564 - val_loss: 1.2748 Epoch 270/300 10/10 - 0s - loss: 1.1558 - val_loss: 1.2903 Epoch 271/300 10/10 - 0s - loss: 1.1699 - val_loss: 1.3047 Epoch 272/300 10/10 - 0s - loss: 1.1511 - val_loss: 1.3155 Epoch 273/300 10/10 - 0s - loss: 1.1574 - val_loss: 1.3227 Epoch 274/300 10/10 - 0s - loss: 1.2026 - val_loss: 1.2986 Epoch 275/300 10/10 - 0s - loss: 1.1880 - val_loss: 1.3880 Epoch 276/300 10/10 - 0s - loss: 1.1912 - val_loss: 1.3257 Epoch 277/300 10/10 - 0s - loss: 1.2500 - val_loss: 1.3678 Epoch 278/300 10/10 - 0s - loss: 1.2577 - val_loss: 1.3459 Epoch 279/300 10/10 - 0s - loss: 1.2060 - val_loss: 1.3124 Epoch 280/300 10/10 - 0s - loss: 1.1785 - val_loss: 1.2839 Epoch 281/300 10/10 - 0s - loss: 1.1617 - val_loss: 1.2958 Epoch 282/300 10/10 - 0s - loss: 1.1535 - val_loss: 1.2837 Epoch 283/300 10/10 - 0s - loss: 1.1544 - val_loss: 1.2685 Epoch 284/300 10/10 - 0s - loss: 1.1444 - val_loss: 1.2963 Epoch 285/300 10/10 - 0s - loss: 1.1540 - val_loss: 1.3266 Epoch 286/300 10/10 - 0s - loss: 1.1817 - val_loss: 1.2867 Epoch 287/300 10/10 - 0s - loss: 1.1504 - val_loss: 1.2798 Epoch 288/300 10/10 - 0s - loss: 1.1495 - val_loss: 1.3050 Epoch 289/300 10/10 - 0s - loss: 1.1667 - val_loss: 1.2821 Epoch 290/300 10/10 - 0s - loss: 1.1761 - val_loss: 1.3154 Epoch 291/300 10/10 - 0s - loss: 1.1608 - val_loss: 1.3160 Epoch 292/300 10/10 - 0s - loss: 1.1688 - val_loss: 1.3394 Epoch 293/300 10/10 - 0s - loss: 1.1595 - val_loss: 1.3182 Epoch 294/300 10/10 - 0s - loss: 1.1630 - val_loss: 1.3249 Epoch 295/300 10/10 - 0s - loss: 1.1427 - val_loss: 1.3061 Epoch 296/300 10/10 - 0s - loss: 1.1473 - val_loss: 1.2985 Epoch 297/300 10/10 - 0s - loss: 1.1393 - val_loss: 1.3054 Epoch 298/300 10/10 - 0s - loss: 1.1641 - val_loss: 1.3133 Epoch 299/300 10/10 - 0s - loss: 1.1740 - val_loss: 1.2902 Epoch 300/300 10/10 - 0s - loss: 1.1717 - val_loss: 1.2780 Performance evaluation plt.figure(figsize=(15, 10)) plt.plot(history.history[\"loss\"]) plt.plot(history.history[\"val_loss\"]) plt.title(\"model loss\") plt.legend([\"train\", \"validation\"], loc=\"upper right\") plt.ylabel(\"loss\") plt.xlabel(\"epoch\") # From data to latent space. z, _ = model(normalized_data) # From latent space to data. samples = model.distribution.sample(3000) x, _ = model.predict(samples) f, axes = plt.subplots(2, 2) f.set_size_inches(20, 15) axes[0, 0].scatter(normalized_data[:, 0], normalized_data[:, 1], color=\"r\") axes[0, 0].set(title=\"Inference data space X\", xlabel=\"x\", ylabel=\"y\") axes[0, 1].scatter(z[:, 0], z[:, 1], color=\"r\") axes[0, 1].set(title=\"Inference latent space Z\", xlabel=\"x\", ylabel=\"y\") axes[0, 1].set_xlim([-3.5, 4]) axes[0, 1].set_ylim([-4, 4]) axes[1, 0].scatter(samples[:, 0], samples[:, 1], color=\"g\") axes[1, 0].set(title=\"Generated latent space Z\", xlabel=\"x\", ylabel=\"y\") axes[1, 1].scatter(x[:, 0], x[:, 1], color=\"g\") axes[1, 1].set(title=\"Generated data space X\", label=\"x\", ylabel=\"y\") axes[1, 1].set_xlim([-2, 2]) axes[1, 1].set_ylim([-2, 2]) (-2.0, 2.0) png png Implementation of StyleGAN Introduction The key idea of StyleGAN is to progressively increase the resolution of the generated images and to incorporate style features in the generative process.This StyleGAN implementation is based on the book Hands-on Image Generation with TensorFlow. The code from the book's Github repository was refactored to leverage a custom train_step() to enable faster training time via compilation and distribution. Setup import os import random import math import numpy as np import matplotlib.pyplot as plt from enum import Enum from glob import glob from functools import partial import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.models import Sequential from tensorflow_addons.layers import InstanceNormalization import tensorflow_datasets as tfds Prepare the dataset In this example, we will train using the CelebA from TensorFlow Datasets. def log2(x): return int(np.log2(x)) # we use different batch size for different resolution, so larger image size # could fit into GPU memory. The keys is image resolution in log2 batch_sizes = {2: 16, 3: 16, 4: 16, 5: 16, 6: 16, 7: 8, 8: 4, 9: 2, 10: 1} # We adjust the train step accordingly train_step_ratio = {k: batch_sizes[2] / v for k, v in batch_sizes.items()} ds_train = tfds.load(\"celeb_a\", split=\"train\") def resize_image(res, sample): image = sample[\"image\"] # only donwsampling, so use nearest neighbor that is faster to run image = tf.image.resize( image, (res, res), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR ) image = tf.cast(image, tf.float32) / 127.5 - 1.0 return image def create_dataloader(res): batch_size = batch_sizes[log2(res)] dl = ds_train.map(partial(resize_image, res), num_parallel_calls=tf.data.AUTOTUNE) dl = dl.shuffle(200).batch(batch_size, drop_remainder=True).prefetch(1).repeat() return dl Utility function to display images after each epoch def plot_images(images, log2_res, fname=\"\"): scales = {2: 0.5, 3: 1, 4: 2, 5: 3, 6: 4, 7: 5, 8: 6, 9: 7, 10: 8} scale = scales[log2_res] grid_col = min(images.shape[0], int(32 // scale)) grid_row = 1 f, axarr = plt.subplots( grid_row, grid_col, figsize=(grid_col * scale, grid_row * scale) ) for row in range(grid_row): ax = axarr if grid_row == 1 else axarr[row] for col in range(grid_col): ax[col].imshow(images[row * grid_col + col]) ax[col].axis(\"off\") plt.show() if fname: f.savefig(fname) Custom Layers The following are building blocks that will be used to construct the generators and discriminators of the StyleGAN model. def fade_in(alpha, a, b): return alpha * a + (1.0 - alpha) * b def wasserstein_loss(y_true, y_pred): return -tf.reduce_mean(y_true * y_pred) def pixel_norm(x, epsilon=1e-8): return x / tf.math.sqrt(tf.reduce_mean(x ** 2, axis=-1, keepdims=True) + epsilon) def minibatch_std(input_tensor, epsilon=1e-8): n, h, w, c = tf.shape(input_tensor) group_size = tf.minimum(4, n) x = tf.reshape(input_tensor, [group_size, -1, h, w, c]) group_mean, group_var = tf.nn.moments(x, axes=(0), keepdims=False) group_std = tf.sqrt(group_var + epsilon) avg_std = tf.reduce_mean(group_std, axis=[1, 2, 3], keepdims=True) x = tf.tile(avg_std, [group_size, h, w, 1]) return tf.concat([input_tensor, x], axis=-1) class EqualizedConv(layers.Layer): def __init__(self, out_channels, kernel=3, gain=2, **kwargs): super(EqualizedConv, self).__init__(**kwargs) self.kernel = kernel self.out_channels = out_channels self.gain = gain self.pad = kernel != 1 def build(self, input_shape): self.in_channels = input_shape[-1] initializer = keras.initializers.RandomNormal(mean=0.0, stddev=1.0) self.w = self.add_weight( shape=[self.kernel, self.kernel, self.in_channels, self.out_channels], initializer=initializer, trainable=True, name=\"kernel\", ) self.b = self.add_weight( shape=(self.out_channels,), initializer=\"zeros\", trainable=True, name=\"bias\" ) fan_in = self.kernel * self.kernel * self.in_channels self.scale = tf.sqrt(self.gain / fan_in) def call(self, inputs): if self.pad: x = tf.pad(inputs, [[0, 0], [1, 1], [1, 1], [0, 0]], mode=\"REFLECT\") else: x = inputs output = ( tf.nn.conv2d(x, self.scale * self.w, strides=1, padding=\"VALID\") + self.b ) return output class EqualizedDense(layers.Layer): def __init__(self, units, gain=2, learning_rate_multiplier=1, **kwargs): super(EqualizedDense, self).__init__(**kwargs) self.units = units self.gain = gain self.learning_rate_multiplier = learning_rate_multiplier def build(self, input_shape): self.in_channels = input_shape[-1] initializer = keras.initializers.RandomNormal( mean=0.0, stddev=1.0 / self.learning_rate_multiplier ) self.w = self.add_weight( shape=[self.in_channels, self.units], initializer=initializer, trainable=True, name=\"kernel\", ) self.b = self.add_weight( shape=(self.units,), initializer=\"zeros\", trainable=True, name=\"bias\" ) fan_in = self.in_channels self.scale = tf.sqrt(self.gain / fan_in) def call(self, inputs): output = tf.add(tf.matmul(inputs, self.scale * self.w), self.b) return output * self.learning_rate_multiplier class AddNoise(layers.Layer): def build(self, input_shape): n, h, w, c = input_shape[0] initializer = keras.initializers.RandomNormal(mean=0.0, stddev=1.0) self.b = self.add_weight( shape=[1, 1, 1, c], initializer=initializer, trainable=True, name=\"kernel\" ) def call(self, inputs): x, noise = inputs output = x + self.b * noise return output class AdaIN(layers.Layer): def __init__(self, gain=1, **kwargs): super(AdaIN, self).__init__(**kwargs) self.gain = gain def build(self, input_shapes): x_shape = input_shapes[0] w_shape = input_shapes[1] self.w_channels = w_shape[-1] self.x_channels = x_shape[-1] self.dense_1 = EqualizedDense(self.x_channels, gain=1) self.dense_2 = EqualizedDense(self.x_channels, gain=1) def call(self, inputs): x, w = inputs ys = tf.reshape(self.dense_1(w), (-1, 1, 1, self.x_channels)) yb = tf.reshape(self.dense_2(w), (-1, 1, 1, self.x_channels)) return ys * x + yb Next we build the following: A model mapping to map the random noise into style code The generator The discriminator For the generator, we build generator blocks at multiple resolutions, e.g. 4x4, 8x8, ...up to 1024x1024. We only use 4x4 in the beginning and we use progressively larger-resolution blocks as the training proceeds. Same for the discriminator. def Mapping(num_stages, input_shape=512): z = layers.Input(shape=(input_shape)) w = pixel_norm(z) for i in range(8): w = EqualizedDense(512, learning_rate_multiplier=0.01)(w) w = layers.LeakyReLU(0.2)(w) w = tf.tile(tf.expand_dims(w, 1), (1, num_stages, 1)) return keras.Model(z, w, name=\"mapping\") class Generator: def __init__(self, start_res_log2, target_res_log2): self.start_res_log2 = start_res_log2 self.target_res_log2 = target_res_log2 self.num_stages = target_res_log2 - start_res_log2 + 1 # list of generator blocks at increasing resolution self.g_blocks = [] # list of layers to convert g_block activation to RGB self.to_rgb = [] # list of noise input of different resolutions into g_blocks self.noise_inputs = [] # filter size to use at each stage, keys are log2(resolution) self.filter_nums = { 0: 512, 1: 512, 2: 512, # 4x4 3: 512, # 8x8 4: 512, # 16x16 5: 512, # 32x32 6: 256, # 64x64 7: 128, # 128x128 8: 64, # 256x256 9: 32, # 512x512 10: 16, } # 1024x1024 start_res = 2 ** start_res_log2 self.input_shape = (start_res, start_res, self.filter_nums[start_res_log2]) self.g_input = layers.Input(self.input_shape, name=\"generator_input\") for i in range(start_res_log2, target_res_log2 + 1): filter_num = self.filter_nums[i] res = 2 ** i self.noise_inputs.append( layers.Input(shape=(res, res, 1), name=f\"noise_{res}x{res}\") ) to_rgb = Sequential( [ layers.InputLayer(input_shape=(res, res, filter_num)), EqualizedConv(3, 1, gain=1), ], name=f\"to_rgb_{res}x{res}\", ) self.to_rgb.append(to_rgb) is_base = i == self.start_res_log2 if is_base: input_shape = (res, res, self.filter_nums[i - 1]) else: input_shape = (2 ** (i - 1), 2 ** (i - 1), self.filter_nums[i - 1]) g_block = self.build_block( filter_num, res=res, input_shape=input_shape, is_base=is_base ) self.g_blocks.append(g_block) def build_block(self, filter_num, res, input_shape, is_base): input_tensor = layers.Input(shape=input_shape, name=f\"g_{res}\") noise = layers.Input(shape=(res, res, 1), name=f\"noise_{res}\") w = layers.Input(shape=512) x = input_tensor if not is_base: x = layers.UpSampling2D((2, 2))(x) x = EqualizedConv(filter_num, 3)(x) x = AddNoise()([x, noise]) x = layers.LeakyReLU(0.2)(x) x = InstanceNormalization()(x) x = AdaIN()([x, w]) x = EqualizedConv(filter_num, 3)(x) x = AddNoise()([x, noise]) x = layers.LeakyReLU(0.2)(x) x = InstanceNormalization()(x) x = AdaIN()([x, w]) return keras.Model([input_tensor, w, noise], x, name=f\"genblock_{res}x{res}\") def grow(self, res_log2): res = 2 ** res_log2 num_stages = res_log2 - self.start_res_log2 + 1 w = layers.Input(shape=(self.num_stages, 512), name=\"w\") alpha = layers.Input(shape=(1), name=\"g_alpha\") x = self.g_blocks[0]([self.g_input, w[:, 0], self.noise_inputs[0]]) if num_stages == 1: rgb = self.to_rgb[0](x) else: for i in range(1, num_stages - 1): x = self.g_blocks[i]([x, w[:, i], self.noise_inputs[i]]) old_rgb = self.to_rgb[num_stages - 2](x) old_rgb = layers.UpSampling2D((2, 2))(old_rgb) i = num_stages - 1 x = self.g_blocks[i]([x, w[:, i], self.noise_inputs[i]]) new_rgb = self.to_rgb[i](x) rgb = fade_in(alpha[0], new_rgb, old_rgb) return keras.Model( [self.g_input, w, self.noise_inputs, alpha], rgb, name=f\"generator_{res}_x_{res}\", ) class Discriminator: def __init__(self, start_res_log2, target_res_log2): self.start_res_log2 = start_res_log2 self.target_res_log2 = target_res_log2 self.num_stages = target_res_log2 - start_res_log2 + 1 # filter size to use at each stage, keys are log2(resolution) self.filter_nums = { 0: 512, 1: 512, 2: 512, # 4x4 3: 512, # 8x8 4: 512, # 16x16 5: 512, # 32x32 6: 256, # 64x64 7: 128, # 128x128 8: 64, # 256x256 9: 32, # 512x512 10: 16, } # 1024x1024 # list of discriminator blocks at increasing resolution self.d_blocks = [] # list of layers to convert RGB into activation for d_blocks inputs self.from_rgb = [] for res_log2 in range(self.start_res_log2, self.target_res_log2 + 1): res = 2 ** res_log2 filter_num = self.filter_nums[res_log2] from_rgb = Sequential( [ layers.InputLayer( input_shape=(res, res, 3), name=f\"from_rgb_input_{res}\" ), EqualizedConv(filter_num, 1), layers.LeakyReLU(0.2), ], name=f\"from_rgb_{res}\", ) self.from_rgb.append(from_rgb) input_shape = (res, res, filter_num) if len(self.d_blocks) == 0: d_block = self.build_base(filter_num, res) else: d_block = self.build_block( filter_num, self.filter_nums[res_log2 - 1], res ) self.d_blocks.append(d_block) def build_base(self, filter_num, res): input_tensor = layers.Input(shape=(res, res, filter_num), name=f\"d_{res}\") x = minibatch_std(input_tensor) x = EqualizedConv(filter_num, 3)(x) x = layers.LeakyReLU(0.2)(x) x = layers.Flatten()(x) x = EqualizedDense(filter_num)(x) x = layers.LeakyReLU(0.2)(x) x = EqualizedDense(1)(x) return keras.Model(input_tensor, x, name=f\"d_{res}\") def build_block(self, filter_num_1, filter_num_2, res): input_tensor = layers.Input(shape=(res, res, filter_num_1), name=f\"d_{res}\") x = EqualizedConv(filter_num_1, 3)(input_tensor) x = layers.LeakyReLU(0.2)(x) x = EqualizedConv(filter_num_2)(x) x = layers.LeakyReLU(0.2)(x) x = layers.AveragePooling2D((2, 2))(x) return keras.Model(input_tensor, x, name=f\"d_{res}\") def grow(self, res_log2): res = 2 ** res_log2 idx = res_log2 - self.start_res_log2 alpha = layers.Input(shape=(1), name=\"d_alpha\") input_image = layers.Input(shape=(res, res, 3), name=\"input_image\") x = self.from_rgb[idx](input_image) x = self.d_blocks[idx](x) if idx > 0: idx -= 1 downsized_image = layers.AveragePooling2D((2, 2))(input_image) y = self.from_rgb[idx](downsized_image) x = fade_in(alpha[0], x, y) for i in range(idx, -1, -1): x = self.d_blocks[i](x) return keras.Model([input_image, alpha], x, name=f\"discriminator_{res}_x_{res}\") Build StyleGAN with custom train step class StyleGAN(tf.keras.Model): def __init__(self, z_dim=512, target_res=64, start_res=4): super(StyleGAN, self).__init__() self.z_dim = z_dim self.target_res_log2 = log2(target_res) self.start_res_log2 = log2(start_res) self.current_res_log2 = self.target_res_log2 self.num_stages = self.target_res_log2 - self.start_res_log2 + 1 self.alpha = tf.Variable(1.0, dtype=tf.float32, trainable=False, name=\"alpha\") self.mapping = Mapping(num_stages=self.num_stages) self.d_builder = Discriminator(self.start_res_log2, self.target_res_log2) self.g_builder = Generator(self.start_res_log2, self.target_res_log2) self.g_input_shape = self.g_builder.input_shape self.phase = None self.train_step_counter = tf.Variable(0, dtype=tf.int32, trainable=False) self.loss_weights = {\"gradient_penalty\": 10, \"drift\": 0.001} def grow_model(self, res): tf.keras.backend.clear_session() res_log2 = log2(res) self.generator = self.g_builder.grow(res_log2) self.discriminator = self.d_builder.grow(res_log2) self.current_res_log2 = res_log2 print(f\"\nModel resolution:{res}x{res}\") def compile( self, steps_per_epoch, phase, res, d_optimizer, g_optimizer, *args, **kwargs ): self.loss_weights = kwargs.pop(\"loss_weights\", self.loss_weights) self.steps_per_epoch = steps_per_epoch if res != 2 ** self.current_res_log2: self.grow_model(res) self.d_optimizer = d_optimizer self.g_optimizer = g_optimizer self.train_step_counter.assign(0) self.phase = phase self.d_loss_metric = keras.metrics.Mean(name=\"d_loss\") self.g_loss_metric = keras.metrics.Mean(name=\"g_loss\") super(StyleGAN, self).compile(*args, **kwargs) @property def metrics(self): return [self.d_loss_metric, self.g_loss_metric] def generate_noise(self, batch_size): noise = [ tf.random.normal((batch_size, 2 ** res, 2 ** res, 1)) for res in range(self.start_res_log2, self.target_res_log2 + 1) ] return noise def gradient_loss(self, grad): loss = tf.square(grad) loss = tf.reduce_sum(loss, axis=tf.range(1, tf.size(tf.shape(loss)))) loss = tf.sqrt(loss) loss = tf.reduce_mean(tf.square(loss - 1)) return loss def train_step(self, real_images): self.train_step_counter.assign_add(1) if self.phase == \"TRANSITION\": self.alpha.assign( tf.cast(self.train_step_counter / self.steps_per_epoch, tf.float32) ) elif self.phase == \"STABLE\": self.alpha.assign(1.0) else: raise NotImplementedError alpha = tf.expand_dims(self.alpha, 0) batch_size = tf.shape(real_images)[0] real_labels = tf.ones(batch_size) fake_labels = -tf.ones(batch_size) z = tf.random.normal((batch_size, self.z_dim)) const_input = tf.ones(tuple([batch_size] + list(self.g_input_shape))) noise = self.generate_noise(batch_size) # generator with tf.GradientTape() as g_tape: w = self.mapping(z) fake_images = self.generator([const_input, w, noise, alpha]) pred_fake = self.discriminator([fake_images, alpha]) g_loss = wasserstein_loss(real_labels, pred_fake) trainable_weights = ( self.mapping.trainable_weights + self.generator.trainable_weights ) gradients = g_tape.gradient(g_loss, trainable_weights) self.g_optimizer.apply_gradients(zip(gradients, trainable_weights)) # discriminator with tf.GradientTape() as gradient_tape, tf.GradientTape() as total_tape: # forward pass pred_fake = self.discriminator([fake_images, alpha]) pred_real = self.discriminator([real_images, alpha]) epsilon = tf.random.uniform((batch_size, 1, 1, 1)) interpolates = epsilon * real_images + (1 - epsilon) * fake_images gradient_tape.watch(interpolates) pred_fake_grad = self.discriminator([interpolates, alpha]) # calculate losses loss_fake = wasserstein_loss(fake_labels, pred_fake) loss_real = wasserstein_loss(real_labels, pred_real) loss_fake_grad = wasserstein_loss(fake_labels, pred_fake_grad) # gradient penalty gradients_fake = gradient_tape.gradient(loss_fake_grad, [interpolates]) gradient_penalty = self.loss_weights[ \"gradient_penalty\" ] * self.gradient_loss(gradients_fake) # drift loss all_pred = tf.concat([pred_fake, pred_real], axis=0) drift_loss = self.loss_weights[\"drift\"] * tf.reduce_mean(all_pred ** 2) d_loss = loss_fake + loss_real + gradient_penalty + drift_loss gradients = total_tape.gradient( d_loss, self.discriminator.trainable_weights ) self.d_optimizer.apply_gradients( zip(gradients, self.discriminator.trainable_weights) ) # Update metrics self.d_loss_metric.update_state(d_loss) self.g_loss_metric.update_state(g_loss) return { \"d_loss\": self.d_loss_metric.result(), \"g_loss\": self.g_loss_metric.result(), } def call(self, inputs: dict()): style_code = inputs.get(\"style_code\", None) z = inputs.get(\"z\", None) noise = inputs.get(\"noise\", None) batch_size = inputs.get(\"batch_size\", 1) alpha = inputs.get(\"alpha\", 1.0) alpha = tf.expand_dims(alpha, 0) if style_code is None: if z is None: z = tf.random.normal((batch_size, self.z_dim)) style_code = self.mapping(z) if noise is None: noise = self.generate_noise(batch_size) # self.alpha.assign(alpha) const_input = tf.ones(tuple([batch_size] + list(self.g_input_shape))) images = self.generator([const_input, style_code, noise, alpha]) images = np.clip((images * 0.5 + 0.5) * 255, 0, 255).astype(np.uint8) return images Training We first build the StyleGAN at smallest resolution, such as 4x4 or 8x8. Then we progressively grow the model to higher resolution by appending new generator and discriminator blocks. START_RES = 4 TARGET_RES = 128 style_gan = StyleGAN(start_res=START_RES, target_res=TARGET_RES) The training for each new resolution happen in two phases - \"transition\" and \"stable\". In the transition phase, the features from the previous resolution are mixed with the current resolution. This allows for a smoother transition when scalling up. We use each epoch in model.fit() as a phase. def train( start_res=START_RES, target_res=TARGET_RES, steps_per_epoch=5000, display_images=True, ): opt_cfg = {\"learning_rate\": 1e-3, \"beta_1\": 0.0, \"beta_2\": 0.99, \"epsilon\": 1e-8} val_batch_size = 16 val_z = tf.random.normal((val_batch_size, style_gan.z_dim)) val_noise = style_gan.generate_noise(val_batch_size) start_res_log2 = int(np.log2(start_res)) target_res_log2 = int(np.log2(target_res)) for res_log2 in range(start_res_log2, target_res_log2 + 1): res = 2 ** res_log2 for phase in [\"TRANSITION\", \"STABLE\"]: if res == start_res and phase == \"TRANSITION\": continue train_dl = create_dataloader(res) steps = int(train_step_ratio[res_log2] * steps_per_epoch) style_gan.compile( d_optimizer=tf.keras.optimizers.Adam(**opt_cfg), g_optimizer=tf.keras.optimizers.Adam(**opt_cfg), loss_weights={\"gradient_penalty\": 10, \"drift\": 0.001}, steps_per_epoch=steps, res=res, phase=phase, run_eagerly=False, ) prefix = f\"res_{res}x{res}_{style_gan.phase}\" ckpt_cb = keras.callbacks.ModelCheckpoint( f\"checkpoints/stylegan_{res}x{res}.ckpt\", save_weights_only=True, verbose=0, ) print(phase) style_gan.fit( train_dl, epochs=1, steps_per_epoch=steps, callbacks=[ckpt_cb] ) if display_images: images = style_gan({\"z\": val_z, \"noise\": val_noise, \"alpha\": 1.0}) plot_images(images, res_log2) StyleGAN can take a long time to train, in the code below, a small steps_per_epoch value of 1 is used to sanity-check the code is working alright. In practice, a larger steps_per_epoch value (over 10000) is required to get decent results. train(start_res=4, target_res=16, steps_per_epoch=1, display_images=False) Model resolution:4x4 STABLE 1/1 [==============================] - 3s 3s/step - d_loss: 2.0971 - g_loss: 2.5965 Model resolution:8x8 TRANSITION 1/1 [==============================] - 5s 5s/step - d_loss: 6.6954 - g_loss: 0.3432 STABLE 1/1 [==============================] - 4s 4s/step - d_loss: 3.3558 - g_loss: 3.7813 Model resolution:16x16 TRANSITION 1/1 [==============================] - 10s 10s/step - d_loss: 3.3166 - g_loss: 6.6047 STABLE WARNING:tensorflow:5 out of the last 5 calls to .train_function at 0x7f7f0e7005e0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details. WARNING:tensorflow:5 out of the last 5 calls to .train_function at 0x7f7f0e7005e0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details. 1/1 [==============================] - 8s 8s/step - d_loss: -6.1128 - g_loss: 17.0095 Results We can now run some inference using pre-trained 64x64 checkpoints. In general, the image fidelity increases with the resolution. You can try to train this StyleGAN to resolutions above 128x128 with the CelebA HQ dataset. url = \"https://github.com/soon-yau/stylegan_keras/releases/download/keras_example_v1.0/stylegan_128x128.ckpt.zip\" weights_path = keras.utils.get_file( \"stylegan_128x128.ckpt.zip\", url, extract=True, cache_dir=os.path.abspath(\".\"), cache_subdir=\"pretrained\", ) style_gan.grow_model(128) style_gan.load_weights(os.path.join(\"pretrained/stylegan_128x128.ckpt\")) tf.random.set_seed(196) batch_size = 2 z = tf.random.normal((batch_size, style_gan.z_dim)) w = style_gan.mapping(z) noise = style_gan.generate_noise(batch_size=batch_size) images = style_gan({\"style_code\": w, \"noise\": noise, \"alpha\": 1.0}) plot_images(images, 5) Downloading data from https://github.com/soon-yau/stylegan_keras/releases/download/keras_example_v1.0/stylegan_128x128.ckpt.zip 540540928/540534982 [==============================] - 30s 0us/step png Style Mixing We can also mix styles from two images to create a new image. alpha = 0.4 w_mix = np.expand_dims(alpha * w[0] + (1 - alpha) * w[1], 0) noise_a = [np.expand_dims(n[0], 0) for n in noise] mix_images = style_gan({\"style_code\": w_mix, \"noise\": noise_a}) image_row = np.hstack([images[0], images[1], mix_images[0]]) plt.figure(figsize=(9, 3)) plt.imshow(image_row) plt.axis(\"off\") (-0.5, 383.5, 127.5, -0.5) png Neural Style Transfer with Adaptive Instance Normalization. Introduction Neural Style Transfer is the process of transferring the style of one image onto the content of another. This was first introduced in the seminal paper \"A Neural Algorithm of Artistic Style\" by Gatys et al. A major limitation of the technique proposed in this work is in its runtime, as the algorithm uses a slow iterative optimization process. Follow-up papers that introduced Batch Normalization, Instance Normalization and Conditional Instance Normalization allowed Style Transfer to be performed in new ways, no longer requiring a slow iterative process. Following these papers, the authors Xun Huang and Serge Belongie propose Adaptive Instance Normalization (AdaIN), which allows arbitrary style transfer in real time. In this example we implement Adapative Instance Normalization for Neural Style Transfer. We show in the below figure the output of our AdaIN model trained for only 30 epochs. Style transfer sample gallery You can also try out the model with your own images with this Hugging Face demo. Setup We begin with importing the necessary packages. We also set the seed for reproducibility. The global variables are hyperparameters which we can change as we like. import os import glob import imageio import numpy as np from tqdm import tqdm import tensorflow as tf from tensorflow import keras import matplotlib.pyplot as plt import tensorflow_datasets as tfds from tensorflow.keras import layers # Defining the global variables. IMAGE_SIZE = (224, 224) BATCH_SIZE = 64 # Training for single epoch for time constraint. # Please use atleast 30 epochs to see good results. EPOCHS = 1 AUTOTUNE = tf.data.AUTOTUNE Style transfer sample gallery For Neural Style Transfer we need style images and content images. In this example we will use the Best Artworks of All Time as our style dataset and Pascal VOC as our content dataset. This is a deviation from the original paper implementation by the authors, where they use WIKI-Art as style and MSCOCO as content datasets respectively. We do this to create a minimal yet reproducible example. Downloading the dataset from Kaggle The Best Artworks of All Time dataset is hosted on Kaggle and one can easily download it in Colab by following these steps: Follow the instructions here in order to obtain your Kaggle API keys in case you don't have them. Use the following command to upload the Kaggle API keys. from google.colab import files files.upload() Use the following commands to move the API keys to the proper directory and download the dataset. $ mkdir ~/.kaggle $ cp kaggle.json ~/.kaggle/ $ chmod 600 ~/.kaggle/kaggle.json $ kaggle datasets download ikarus777/best-artworks-of-all-time $ unzip -qq best-artworks-of-all-time.zip $ rm -rf images $ mv resized artwork $ rm best-artworks-of-all-time.zip artists.csv tf.data pipeline In this section, we will build the tf.data pipeline for the project. For the style dataset, we decode, convert and resize the images from the folder. For the content images we are already presented with a tf.data dataset as we use the tfds module. After we have our style and content data pipeline ready, we zip the two together to obtain the data pipeline that our model will consume. def decode_and_resize(image_path): \"\"\"Decodes and resizes an image from the image file path. Args: image_path: The image file path. size: The size of the image to be resized to. Returns: A resized image. \"\"\" image = tf.io.read_file(image_path) image = tf.image.decode_jpeg(image, channels=3) image = tf.image.convert_image_dtype(image, dtype=\"float32\") image = tf.image.resize(image, IMAGE_SIZE) return image def extract_image_from_voc(element): \"\"\"Extracts image from the PascalVOC dataset. Args: element: A dictionary of data. size: The size of the image to be resized to. Returns: A resized image. \"\"\" image = element[\"image\"] image = tf.image.convert_image_dtype(image, dtype=\"float32\") image = tf.image.resize(image, IMAGE_SIZE) return image # Get the image file paths for the style images. style_images = os.listdir(\"/content/artwork/resized\") style_images = [os.path.join(\"/content/artwork/resized\", path) for path in style_images] # split the style images in train, val and test total_style_images = len(style_images) train_style = style_images[: int(0.8 * total_style_images)] val_style = style_images[int(0.8 * total_style_images) : int(0.9 * total_style_images)] test_style = style_images[int(0.9 * total_style_images) :] # Build the style and content tf.data datasets. train_style_ds = ( tf.data.Dataset.from_tensor_slices(train_style) .map(decode_and_resize, num_parallel_calls=AUTOTUNE) .repeat() ) train_content_ds = tfds.load(\"voc\", split=\"train\").map(extract_image_from_voc).repeat() val_style_ds = ( tf.data.Dataset.from_tensor_slices(val_style) .map(decode_and_resize, num_parallel_calls=AUTOTUNE) .repeat() ) val_content_ds = ( tfds.load(\"voc\", split=\"validation\").map(extract_image_from_voc).repeat() ) test_style_ds = ( tf.data.Dataset.from_tensor_slices(test_style) .map(decode_and_resize, num_parallel_calls=AUTOTUNE) .repeat() ) test_content_ds = ( tfds.load(\"voc\", split=\"test\") .map(extract_image_from_voc, num_parallel_calls=AUTOTUNE) .repeat() ) # Zipping the style and content datasets. train_ds = ( tf.data.Dataset.zip((train_style_ds, train_content_ds)) .shuffle(BATCH_SIZE * 2) .batch(BATCH_SIZE) .prefetch(AUTOTUNE) ) val_ds = ( tf.data.Dataset.zip((val_style_ds, val_content_ds)) .shuffle(BATCH_SIZE * 2) .batch(BATCH_SIZE) .prefetch(AUTOTUNE) ) test_ds = ( tf.data.Dataset.zip((test_style_ds, test_content_ds)) .shuffle(BATCH_SIZE * 2) .batch(BATCH_SIZE) .prefetch(AUTOTUNE) ) Downloading and preparing dataset voc/2007/4.0.0 (download: 868.85 MiB, generated: Unknown size, total: 868.85 MiB) to /root/tensorflow_datasets/voc/2007/4.0.0... Dl Completed...: 0 url [00:00, ? url/s] Dl Size...: 0 MiB [00:00, ? MiB/s] Extraction completed...: 0 file [00:00, ? file/s] 0 examples [00:00, ? examples/s] Shuffling and writing examples to /root/tensorflow_datasets/voc/2007/4.0.0.incompleteP16YU5/voc-test.tfrecord 0%| | 0/4952 [00:00'RGB' x = x[:, :, ::-1] x = np.clip(x, 0, 255).astype(\"uint8\") return x Compute the style transfer loss First, we need to define 4 utility functions: gram_matrix (used to compute the style loss) The style_loss function, which keeps the generated image close to the local textures of the style reference image The content_loss function, which keeps the high-level representation of the generated image close to that of the base image The total_variation_loss function, a regularization loss which keeps the generated image locally-coherent # The gram matrix of an image tensor (feature-wise outer product) def gram_matrix(x): x = tf.transpose(x, (2, 0, 1)) features = tf.reshape(x, (tf.shape(x)[0], -1)) gram = tf.matmul(features, tf.transpose(features)) return gram # The \"style loss\" is designed to maintain # the style of the reference image in the generated image. # It is based on the gram matrices (which capture style) of # feature maps from the style reference image # and from the generated image def style_loss(style, combination): S = gram_matrix(style) C = gram_matrix(combination) channels = 3 size = img_nrows * img_ncols return tf.reduce_sum(tf.square(S - C)) / (4.0 * (channels ** 2) * (size ** 2)) # An auxiliary loss function # designed to maintain the \"content\" of the # base image in the generated image def content_loss(base, combination): return tf.reduce_sum(tf.square(combination - base)) # The 3rd loss function, total variation loss, # designed to keep the generated image locally coherent def total_variation_loss(x): a = tf.square( x[:, : img_nrows - 1, : img_ncols - 1, :] - x[:, 1:, : img_ncols - 1, :] ) b = tf.square( x[:, : img_nrows - 1, : img_ncols - 1, :] - x[:, : img_nrows - 1, 1:, :] ) return tf.reduce_sum(tf.pow(a + b, 1.25)) Next, let's create a feature extraction model that retrieves the intermediate activations of VGG19 (as a dict, by name). # Build a VGG19 model loaded with pre-trained ImageNet weights model = vgg19.VGG19(weights=\"imagenet\", include_top=False) # Get the symbolic outputs of each \"key\" layer (we gave them unique names). outputs_dict = dict([(layer.name, layer.output) for layer in model.layers]) # Set up a model that returns the activation values for every layer in # VGG19 (as a dict). feature_extractor = keras.Model(inputs=model.inputs, outputs=outputs_dict) Finally, here's the code that computes the style transfer loss. # List of layers to use for the style loss. style_layer_names = [ \"block1_conv1\", \"block2_conv1\", \"block3_conv1\", \"block4_conv1\", \"block5_conv1\", ] # The layer to use for the content loss. content_layer_name = \"block5_conv2\" def compute_loss(combination_image, base_image, style_reference_image): input_tensor = tf.concat( [base_image, style_reference_image, combination_image], axis=0 ) features = feature_extractor(input_tensor) # Initialize the loss loss = tf.zeros(shape=()) # Add content loss layer_features = features[content_layer_name] base_image_features = layer_features[0, :, :, :] combination_features = layer_features[2, :, :, :] loss = loss + content_weight * content_loss( base_image_features, combination_features ) # Add style loss for layer_name in style_layer_names: layer_features = features[layer_name] style_reference_features = layer_features[1, :, :, :] combination_features = layer_features[2, :, :, :] sl = style_loss(style_reference_features, combination_features) loss += (style_weight / len(style_layer_names)) * sl # Add total variation loss loss += total_variation_weight * total_variation_loss(combination_image) return loss Add a tf.function decorator to loss & gradient computation To compile it, and thus make it fast. @tf.function def compute_loss_and_grads(combination_image, base_image, style_reference_image): with tf.GradientTape() as tape: loss = compute_loss(combination_image, base_image, style_reference_image) grads = tape.gradient(loss, combination_image) return loss, grads The training loop Repeatedly run vanilla gradient descent steps to minimize the loss, and save the resulting image every 100 iterations. We decay the learning rate by 0.96 every 100 steps. optimizer = keras.optimizers.SGD( keras.optimizers.schedules.ExponentialDecay( initial_learning_rate=100.0, decay_steps=100, decay_rate=0.96 ) ) base_image = preprocess_image(base_image_path) style_reference_image = preprocess_image(style_reference_image_path) combination_image = tf.Variable(preprocess_image(base_image_path)) iterations = 4000 for i in range(1, iterations + 1): loss, grads = compute_loss_and_grads( combination_image, base_image, style_reference_image ) optimizer.apply_gradients([(grads, combination_image)]) if i % 100 == 0: print(\"Iteration %d: loss=%.2f\" % (i, loss)) img = deprocess_image(combination_image.numpy()) fname = result_prefix + \"_at_iteration_%d.png\" % i keras.preprocessing.image.save_img(fname, img) Iteration 100: loss=11018.36 Iteration 200: loss=8514.28 Iteration 300: loss=7571.70 Iteration 400: loss=7064.09 Iteration 500: loss=6736.33 Iteration 600: loss=6501.82 Iteration 700: loss=6323.21 Iteration 800: loss=6181.44 Iteration 900: loss=6065.30 Iteration 1000: loss=5967.72 Iteration 1100: loss=5884.61 Iteration 1200: loss=5812.84 Iteration 1300: loss=5750.36 Iteration 1400: loss=5695.61 Iteration 1500: loss=5647.19 Iteration 1600: loss=5604.15 Iteration 1700: loss=5565.45 Iteration 1800: loss=5530.61 Iteration 1900: loss=5498.99 Iteration 2000: loss=5470.26 Iteration 2100: loss=5444.05 Iteration 2200: loss=5420.09 Iteration 2300: loss=5398.12 Iteration 2400: loss=5377.92 Iteration 2500: loss=5359.31 Iteration 2600: loss=5342.14 Iteration 2700: loss=5326.28 Iteration 2800: loss=5311.56 Iteration 2900: loss=5297.89 Iteration 3000: loss=5285.14 Iteration 3100: loss=5273.21 Iteration 3200: loss=5262.05 Iteration 3300: loss=5251.60 Iteration 3400: loss=5241.82 Iteration 3500: loss=5232.64 Iteration 3600: loss=5224.02 Iteration 3700: loss=5215.90 Iteration 3800: loss=5208.26 Iteration 3900: loss=5201.06 Iteration 4000: loss=5194.26 After 4000 iterations, you get the following result: display(Image(result_prefix + \"_at_iteration_4000.png\")) png PixelCNN implemented in Keras. Introduction PixelCNN is a generative model proposed in 2016 by van den Oord et al. (reference: Conditional Image Generation with PixelCNN Decoders). It is designed to generate images (or other data types) iteratively from an input vector where the probability distribution of prior elements dictates the probability distribution of later elements. In the following example, images are generated in this fashion, pixel-by-pixel, via a masked convolution kernel that only looks at data from previously generated pixels (origin at the top left) to generate later pixels. During inference, the output of the network is used as a probability distribution from which new pixel values are sampled to generate a new image (here, with MNIST, the pixel values range from white (0) to black (255)). import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tqdm import tqdm Getting the data # Model / data parameters num_classes = 10 input_shape = (28, 28, 1) n_residual_blocks = 5 # The data, split between train and test sets (x, _), (y, _) = keras.datasets.mnist.load_data() # Concatenate all of the images together data = np.concatenate((x, y), axis=0) # Round all pixel values less than 33% of the max 256 value to 0 # anything above this value gets rounded up to 1 so that all values are either # 0 or 1 data = np.where(data < (0.33 * 256), 0, 1) data = data.astype(np.float32) Create two classes for the requisite Layers for the model # The first layer is the PixelCNN layer. This layer simply # builds on the 2D convolutional layer, but includes masking. class PixelConvLayer(layers.Layer): def __init__(self, mask_type, **kwargs): super(PixelConvLayer, self).__init__() self.mask_type = mask_type self.conv = layers.Conv2D(**kwargs) def build(self, input_shape): # Build the conv2d layer to initialize kernel variables self.conv.build(input_shape) # Use the initialized kernel to create the mask kernel_shape = self.conv.kernel.get_shape() self.mask = np.zeros(shape=kernel_shape) self.mask[: kernel_shape[0] // 2, ...] = 1.0 self.mask[kernel_shape[0] // 2, : kernel_shape[1] // 2, ...] = 1.0 if self.mask_type == \"B\": self.mask[kernel_shape[0] // 2, kernel_shape[1] // 2, ...] = 1.0 def call(self, inputs): self.conv.kernel.assign(self.conv.kernel * self.mask) return self.conv(inputs) # Next, we build our residual block layer. # This is just a normal residual block, but based on the PixelConvLayer. class ResidualBlock(keras.layers.Layer): def __init__(self, filters, **kwargs): super(ResidualBlock, self).__init__(**kwargs) self.conv1 = keras.layers.Conv2D( filters=filters, kernel_size=1, activation=\"relu\" ) self.pixel_conv = PixelConvLayer( mask_type=\"B\", filters=filters // 2, kernel_size=3, activation=\"relu\", padding=\"same\", ) self.conv2 = keras.layers.Conv2D( filters=filters, kernel_size=1, activation=\"relu\" ) def call(self, inputs): x = self.conv1(inputs) x = self.pixel_conv(x) x = self.conv2(x) return keras.layers.add([inputs, x]) Build the model based on the original paper inputs = keras.Input(shape=input_shape) x = PixelConvLayer( mask_type=\"A\", filters=128, kernel_size=7, activation=\"relu\", padding=\"same\" )(inputs) for _ in range(n_residual_blocks): x = ResidualBlock(filters=128)(x) for _ in range(2): x = PixelConvLayer( mask_type=\"B\", filters=128, kernel_size=1, strides=1, activation=\"relu\", padding=\"valid\", )(x) out = keras.layers.Conv2D( filters=1, kernel_size=1, strides=1, activation=\"sigmoid\", padding=\"valid\" )(x) pixel_cnn = keras.Model(inputs, out) adam = keras.optimizers.Adam(learning_rate=0.0005) pixel_cnn.compile(optimizer=adam, loss=\"binary_crossentropy\") pixel_cnn.summary() pixel_cnn.fit( x=data, y=data, batch_size=128, epochs=50, validation_split=0.1, verbose=2 ) Model: \"model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 28, 28, 1)] 0 _________________________________________________________________ pixel_conv_layer (PixelConvL (None, 28, 28, 128) 6400 _________________________________________________________________ residual_block (ResidualBloc (None, 28, 28, 128) 98624 _________________________________________________________________ residual_block_1 (ResidualBl (None, 28, 28, 128) 98624 _________________________________________________________________ residual_block_2 (ResidualBl (None, 28, 28, 128) 98624 _________________________________________________________________ residual_block_3 (ResidualBl (None, 28, 28, 128) 98624 _________________________________________________________________ residual_block_4 (ResidualBl (None, 28, 28, 128) 98624 _________________________________________________________________ pixel_conv_layer_6 (PixelCon (None, 28, 28, 128) 16512 _________________________________________________________________ pixel_conv_layer_7 (PixelCon (None, 28, 28, 128) 16512 _________________________________________________________________ conv2d_18 (Conv2D) (None, 28, 28, 1) 129 ================================================================= Total params: 532,673 Trainable params: 532,673 Non-trainable params: 0 _________________________________________________________________ Epoch 1/50 493/493 - 18s - loss: 0.1163 - val_loss: 0.0937 Epoch 2/50 493/493 - 18s - loss: 0.0911 - val_loss: 0.0908 Epoch 3/50 493/493 - 18s - loss: 0.0889 - val_loss: 0.0890 Epoch 4/50 493/493 - 18s - loss: 0.0878 - val_loss: 0.0879 Epoch 5/50 493/493 - 18s - loss: 0.0871 - val_loss: 0.0868 Epoch 6/50 493/493 - 18s - loss: 0.0865 - val_loss: 0.0875 Epoch 7/50 493/493 - 18s - loss: 0.0861 - val_loss: 0.0857 Epoch 8/50 493/493 - 18s - loss: 0.0857 - val_loss: 0.0860 Epoch 9/50 493/493 - 18s - loss: 0.0854 - val_loss: 0.0855 Epoch 10/50 493/493 - 18s - loss: 0.0850 - val_loss: 0.0853 Epoch 11/50 493/493 - 18s - loss: 0.0848 - val_loss: 0.0849 Epoch 12/50 493/493 - 18s - loss: 0.0846 - val_loss: 0.0850 Epoch 13/50 493/493 - 18s - loss: 0.0844 - val_loss: 0.0849 Epoch 14/50 493/493 - 18s - loss: 0.0842 - val_loss: 0.0845 Epoch 15/50 493/493 - 18s - loss: 0.0840 - val_loss: 0.0850 Epoch 16/50 493/493 - 18s - loss: 0.0839 - val_loss: 0.0850 Epoch 17/50 493/493 - 18s - loss: 0.0837 - val_loss: 0.0843 Epoch 18/50 493/493 - 18s - loss: 0.0836 - val_loss: 0.0842 Epoch 19/50 493/493 - 18s - loss: 0.0835 - val_loss: 0.0840 Epoch 20/50 493/493 - 18s - loss: 0.0834 - val_loss: 0.0842 Epoch 21/50 493/493 - 18s - loss: 0.0832 - val_loss: 0.0837 Epoch 22/50 493/493 - 18s - loss: 0.0831 - val_loss: 0.0839 Epoch 23/50 493/493 - 18s - loss: 0.0830 - val_loss: 0.0835 Epoch 24/50 493/493 - 18s - loss: 0.0829 - val_loss: 0.0839 Epoch 25/50 493/493 - 18s - loss: 0.0829 - val_loss: 0.0835 Epoch 26/50 493/493 - 18s - loss: 0.0827 - val_loss: 0.0836 Epoch 27/50 493/493 - 18s - loss: 0.0827 - val_loss: 0.0834 Epoch 28/50 493/493 - 18s - loss: 0.0826 - val_loss: 0.0834 Epoch 29/50 493/493 - 18s - loss: 0.0825 - val_loss: 0.0834 Epoch 30/50 493/493 - 18s - loss: 0.0824 - val_loss: 0.0834 Epoch 31/50 493/493 - 18s - loss: 0.0823 - val_loss: 0.0832 Epoch 32/50 493/493 - 18s - loss: 0.0823 - val_loss: 0.0832 Epoch 33/50 493/493 - 18s - loss: 0.0822 - val_loss: 0.0833 Epoch 34/50 493/493 - 18s - loss: 0.0821 - val_loss: 0.0835 Epoch 35/50 493/493 - 18s - loss: 0.0821 - val_loss: 0.0834 Epoch 36/50 493/493 - 18s - loss: 0.0820 - val_loss: 0.0837 Epoch 37/50 493/493 - 18s - loss: 0.0820 - val_loss: 0.0832 Epoch 38/50 493/493 - 18s - loss: 0.0819 - val_loss: 0.0834 Epoch 39/50 493/493 - 18s - loss: 0.0818 - val_loss: 0.0834 Epoch 40/50 493/493 - 18s - loss: 0.0818 - val_loss: 0.0832 Epoch 41/50 493/493 - 18s - loss: 0.0817 - val_loss: 0.0834 Epoch 42/50 493/493 - 18s - loss: 0.0817 - val_loss: 0.0836 Epoch 43/50 493/493 - 18s - loss: 0.0816 - val_loss: 0.0833 Epoch 44/50 493/493 - 18s - loss: 0.0816 - val_loss: 0.0835 Epoch 45/50 493/493 - 18s - loss: 0.0815 - val_loss: 0.0832 Epoch 46/50 493/493 - 18s - loss: 0.0815 - val_loss: 0.0830 Epoch 47/50 493/493 - 18s - loss: 0.0814 - val_loss: 0.0831 Epoch 48/50 493/493 - 18s - loss: 0.0813 - val_loss: 0.0832 Epoch 49/50 493/493 - 18s - loss: 0.0813 - val_loss: 0.0834 Epoch 50/50 493/493 - 18s - loss: 0.0813 - val_loss: 0.0832 Demonstration The PixelCNN cannot generate the full image at once. Instead, it must generate each pixel in order, append the last generated pixel to the current image, and feed the image back into the model to repeat the process. from IPython.display import Image, display # Create an empty array of pixels. batch = 4 pixels = np.zeros(shape=(batch,) + (pixel_cnn.input_shape)[1:]) batch, rows, cols, channels = pixels.shape # Iterate over the pixels because generation has to be done sequentially pixel by pixel. for row in tqdm(range(rows)): for col in range(cols): for channel in range(channels): # Feed the whole array and retrieving the pixel value probabilities for the next # pixel. probs = pixel_cnn.predict(pixels)[:, row, col, channel] # Use the probabilities to pick pixel values and append the values to the image # frame. pixels[:, row, col, channel] = tf.math.ceil( probs - tf.random.uniform(probs.shape) ) def deprocess_image(x): # Stack the single channeled black and white image to RGB values. x = np.stack((x, x, x), 2) # Undo preprocessing x *= 255.0 # Convert to uint8 and clip to the valid range [0, 255] x = np.clip(x, 0, 255).astype(\"uint8\") return x # Iterate over the generated images and plot them with matplotlib. for i, pic in enumerate(pixels): keras.preprocessing.image.save_img( \"generated_image_{}.png\".format(i), deprocess_image(np.squeeze(pic, -1)) ) display(Image(\"generated_image_0.png\")) display(Image(\"generated_image_1.png\")) display(Image(\"generated_image_2.png\")) display(Image(\"generated_image_3.png\")) 100%|██████████| 28/28 [00:18<00:00, 1.51it/s] png png png Implement a miniature version of GPT and train it to generate text. Introduction This example demonstrates how to implement an autoregressive language model using a miniature version of the GPT model. The model consists of a single Transformer block with causal masking in its attention layer. We use the text from the IMDB sentiment classification dataset for training and generate new movie reviews for a given prompt. When using this script with your own dataset, make sure it has at least 1 million words. This example should be run with tf-nightly>=2.3.0-dev20200531 or with TensorFlow 2.3 or higher. References: GPT GPT-2 GPT-3 Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.layers import TextVectorization import numpy as np import os import re import string import random Implement a Transformer block as a layer def causal_attention_mask(batch_size, n_dest, n_src, dtype): \"\"\" Mask the upper half of the dot product matrix in self attention. This prevents flow of information from future tokens to current token. 1's in the lower triangle, counting from the lower right corner. \"\"\" i = tf.range(n_dest)[:, None] j = tf.range(n_src) m = i >= j - n_src + n_dest mask = tf.cast(m, dtype) mask = tf.reshape(mask, [1, n_dest, n_src]) mult = tf.concat( [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)], 0 ) return tf.tile(mask, mult) class TransformerBlock(layers.Layer): def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1): super(TransformerBlock, self).__init__() self.att = layers.MultiHeadAttention(num_heads, embed_dim) self.ffn = keras.Sequential( [layers.Dense(ff_dim, activation=\"relu\"), layers.Dense(embed_dim),] ) self.layernorm1 = layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = layers.LayerNormalization(epsilon=1e-6) self.dropout1 = layers.Dropout(rate) self.dropout2 = layers.Dropout(rate) def call(self, inputs): input_shape = tf.shape(inputs) batch_size = input_shape[0] seq_len = input_shape[1] causal_mask = causal_attention_mask(batch_size, seq_len, seq_len, tf.bool) attention_output = self.att(inputs, inputs, attention_mask=causal_mask) attention_output = self.dropout1(attention_output) out1 = self.layernorm1(inputs + attention_output) ffn_output = self.ffn(out1) ffn_output = self.dropout2(ffn_output) return self.layernorm2(out1 + ffn_output) Implement an embedding layer Create two seperate embedding layers: one for tokens and one for token index (positions). class TokenAndPositionEmbedding(layers.Layer): def __init__(self, maxlen, vocab_size, embed_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = layers.Embedding(input_dim=vocab_size, output_dim=embed_dim) self.pos_emb = layers.Embedding(input_dim=maxlen, output_dim=embed_dim) def call(self, x): maxlen = tf.shape(x)[-1] positions = tf.range(start=0, limit=maxlen, delta=1) positions = self.pos_emb(positions) x = self.token_emb(x) return x + positions Implement the miniature GPT model vocab_size = 20000 # Only consider the top 20k words maxlen = 80 # Max sequence size embed_dim = 256 # Embedding size for each token num_heads = 2 # Number of attention heads feed_forward_dim = 256 # Hidden layer size in feed forward network inside transformer def create_model(): inputs = layers.Input(shape=(maxlen,), dtype=tf.int32) embedding_layer = TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) x = embedding_layer(inputs) transformer_block = TransformerBlock(embed_dim, num_heads, feed_forward_dim) x = transformer_block(x) outputs = layers.Dense(vocab_size)(x) model = keras.Model(inputs=inputs, outputs=[outputs, x]) loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) model.compile( \"adam\", loss=[loss_fn, None], ) # No loss and optimization based on word embeddings from transformer block return model Prepare the data for word-level language modelling Download the IMDB dataset and combine training and validation sets for a text generation task. !curl -O https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz !tar -xf aclImdb_v1.tar.gz batch_size = 128 # The dataset contains each review in a separate text file # The text files are present in four different folders # Create a list all files filenames = [] directories = [ \"aclImdb/train/pos\", \"aclImdb/train/neg\", \"aclImdb/test/pos\", \"aclImdb/test/neg\", ] for dir in directories: for f in os.listdir(dir): filenames.append(os.path.join(dir, f)) print(f\"{len(filenames)} files\") # Create a dataset from text files random.shuffle(filenames) text_ds = tf.data.TextLineDataset(filenames) text_ds = text_ds.shuffle(buffer_size=256) text_ds = text_ds.batch(batch_size) def custom_standardization(input_string): \"\"\" Remove html line-break tags and handle punctuation \"\"\" lowercased = tf.strings.lower(input_string) stripped_html = tf.strings.regex_replace(lowercased, \"
\", \" \") return tf.strings.regex_replace(stripped_html, f\"([{string.punctuation}])\", r\" \1\") # Create a vectorization layer and adapt it to the text vectorize_layer = TextVectorization( standardize=custom_standardization, max_tokens=vocab_size - 1, output_mode=\"int\", output_sequence_length=maxlen + 1, ) vectorize_layer.adapt(text_ds) vocab = vectorize_layer.get_vocabulary() # To get words back from token indices def prepare_lm_inputs_labels(text): \"\"\" Shift word sequences by 1 position so that the target for position (i) is word at position (i+1). The model will use all words up till position (i) to predict the next word. \"\"\" text = tf.expand_dims(text, -1) tokenized_sentences = vectorize_layer(text) x = tokenized_sentences[:, :-1] y = tokenized_sentences[:, 1:] return x, y text_ds = text_ds.map(prepare_lm_inputs_labels) text_ds = text_ds.prefetch(tf.data.AUTOTUNE) % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 80.2M 100 80.2M 0 0 24.2M 0 0:00:03 0:00:03 --:--:-- 24.2M 50000 files Implement a Keras callback for generating text class TextGenerator(keras.callbacks.Callback): \"\"\"A callback to generate text from a trained model. 1. Feed some starting prompt to the model 2. Predict probabilities for the next token 3. Sample the next token and add it to the next input Arguments: max_tokens: Integer, the number of tokens to be generated after prompt. start_tokens: List of integers, the token indices for the starting prompt. index_to_word: List of strings, obtained from the TextVectorization layer. top_k: Integer, sample from the `top_k` token predictions. print_every: Integer, print after this many epochs. \"\"\" def __init__( self, max_tokens, start_tokens, index_to_word, top_k=10, print_every=1 ): self.max_tokens = max_tokens self.start_tokens = start_tokens self.index_to_word = index_to_word self.print_every = print_every self.k = top_k def sample_from(self, logits): logits, indices = tf.math.top_k(logits, k=self.k, sorted=True) indices = np.asarray(indices).astype(\"int32\") preds = keras.activations.softmax(tf.expand_dims(logits, 0))[0] preds = np.asarray(preds).astype(\"float32\") return np.random.choice(indices, p=preds) def detokenize(self, number): return self.index_to_word[number] def on_epoch_end(self, epoch, logs=None): start_tokens = [_ for _ in self.start_tokens] if (epoch + 1) % self.print_every != 0: return num_tokens_generated = 0 tokens_generated = [] while num_tokens_generated <= self.max_tokens: pad_len = maxlen - len(start_tokens) sample_index = len(start_tokens) - 1 if pad_len < 0: x = start_tokens[:maxlen] sample_index = maxlen - 1 elif pad_len > 0: x = start_tokens + [0] * pad_len else: x = start_tokens x = np.array([x]) y, _ = self.model.predict(x) sample_token = self.sample_from(y[0][sample_index]) tokens_generated.append(sample_token) start_tokens.append(sample_token) num_tokens_generated = len(tokens_generated) txt = \" \".join( [self.detokenize(_) for _ in self.start_tokens + tokens_generated] ) print(f\"generated text:\n{txt}\n\") # Tokenize starting prompt word_to_index = {} for index, word in enumerate(vocab): word_to_index[word] = index start_prompt = \"this movie is\" start_tokens = [word_to_index.get(_, 1) for _ in start_prompt.split()] num_tokens_generated = 40 text_gen_callback = TextGenerator(num_tokens_generated, start_tokens, vocab) Train the model Note: This code should preferably be run on GPU. model = create_model() model.fit(text_ds, verbose=2, epochs=25, callbacks=[text_gen_callback]) Epoch 1/25 391/391 - 135s - loss: 5.5949 - dense_2_loss: 5.5949 generated text: this movie is a great movie . the film is so many other comments . the plot and some people were [UNK] to do . i think the story is about that it is not a good movie . there are very good actors Epoch 2/25 391/391 - 135s - loss: 4.7108 - dense_2_loss: 4.7108 generated text: this movie is one of the worst movies i have ever seen . i have no doubt the better movies of this one 's worst movies i have ever seen . i don 't know what the hell , and i 'm not going Epoch 3/25 391/391 - 135s - loss: 4.4620 - dense_2_loss: 4.4620 generated text: this movie is a very good movie , i think i am not a kid . the story is a great movie . the director who is a great director who likes the director 's film . this was not funny and the director Epoch 4/25 391/391 - 136s - loss: 4.3047 - dense_2_loss: 4.3047 generated text: this movie is a very good story and very well . this movie is one of the worst movies i have ever seen , and there are some good actors and actresses in the movie , it is not the worst . the script Epoch 5/25 391/391 - 135s - loss: 4.1840 - dense_2_loss: 4.1840 generated text: this movie is a very good movie . it is the best thing about it 's a very good movie . it 's not funny , very , it 's so bad that it 's so funny , it 's like most romantic movie Epoch 6/25 391/391 - 135s - loss: 4.0834 - dense_2_loss: 4.0834 generated text: this movie is the worst . the acting is awful . i have to admit that you 're just watching this film as i have to say that it is a [UNK] with [UNK] [UNK] \" in the last ten years . i think Epoch 7/25 391/391 - 135s - loss: 3.9987 - dense_2_loss: 3.9987 generated text: this movie is really about the acting is good and the script . i don 't think this is just a waste of movie . it was so terrible that it wasn 't funny , but that 's what it was made in movies Epoch 8/25 391/391 - 134s - loss: 3.9242 - dense_2_loss: 3.9242 generated text: this movie is so bad . the story itself is about a family guy named jack , who is told by a father , who is trying to get to help him to commit . he has the same problem and the [UNK] . Epoch 9/25 391/391 - 135s - loss: 3.8579 - dense_2_loss: 3.8579 generated text: this movie is not bad , it does not deserve one . i can say that i was able to sit at , relax [UNK] . i was wrong , and i think i was able to buy the dvd , i would say Epoch 10/25 391/391 - 134s - loss: 3.7989 - dense_2_loss: 3.7989 generated text: this movie is very funny ! its very funny . a touching movie about three women who don 't know who is not to go on with a movie that has a lot of fun to watch . it is funny . the main Epoch 11/25 391/391 - 134s - loss: 3.7459 - dense_2_loss: 3.7459 generated text: this movie is not the best movie i 've seen in a long time . this movie was just about a guy who gets killed for one . . i saw this movie at a time when i first saw it in the movie Epoch 12/25 391/391 - 134s - loss: 3.6974 - dense_2_loss: 3.6974 generated text: this movie is a good example of how many films have seen and many films , that are often overlooked , in the seventies , in fact it is more enjoyable than the average viewer has some interesting parallels . this movie is based Epoch 13/25 391/391 - 134s - loss: 3.6534 - dense_2_loss: 3.6534 generated text: this movie is so bad ! i think this is one . i really didn 't think anybody who gets the impression that the people who is trying to find themselves to be funny . . there 's the humor is no punchline ? Epoch 14/25 391/391 - 134s - loss: 3.6123 - dense_2_loss: 3.6123 generated text: this movie is really bad . the actors are good ,the acting is great . a must see [UNK] the worst in history of all time . the plot is so bad that you can 't even make a bad movie about the bad Epoch 15/25 391/391 - 134s - loss: 3.5745 - dense_2_loss: 3.5745 generated text: this movie is one of the worst movies i 've ever had . the acting and direction are terrible . what i 've seen , i 've watched it several times , and i can 't really believe how to make a movie about Epoch 16/25 391/391 - 134s - loss: 3.5404 - dense_2_loss: 3.5404 generated text: this movie is so bad it is . that it is supposed to be a comedy . the script , which is just as bad as some movies are bad . if you 're looking for it , if you 're in the mood Epoch 17/25 391/391 - 134s - loss: 3.5083 - dense_2_loss: 3.5083 generated text: this movie is one of all bad movies i have a fan ever seen . i have seen a good movies , this isn 't the worst . i 've seen in a long time . the story involves twins , a priest and Epoch 18/25 391/391 - 134s - loss: 3.4789 - dense_2_loss: 3.4789 generated text: this movie is a great movie . it 's a shame that it was hard to see that it was . this movie is a good movie . the movie itself is a complete waste of time and time you have a bad rant Epoch 19/25 391/391 - 134s - loss: 3.4513 - dense_2_loss: 3.4513 generated text: this movie is not one of the most moving movies i have ever seen . the story is about the plot is just so ridiculous that i could have done it with the actors . the actors are great and the acting is great Epoch 20/25 391/391 - 134s - loss: 3.4251 - dense_2_loss: 3.4251 generated text: this movie is about a man named todd . it is a funny movie that has a lot of nerve on screen . it is not just the right ingredients and a movie . it is a great film , and it is a Epoch 21/25 391/391 - 134s - loss: 3.4011 - dense_2_loss: 3.4011 generated text: this movie is not only funny , but i have never seen it before . the other comments i am not kidding or have been [UNK] and the worst movie i have to be . . there is something that is no where else Epoch 22/25 391/391 - 134s - loss: 3.3787 - dense_2_loss: 3.3787 generated text: this movie is a very entertaining , very funny , and very funny , very well written and very nicely directed movie . this was done , very well done , with very good acting and a wonderful script , a very good movie Epoch 23/25 391/391 - 133s - loss: 3.3575 - dense_2_loss: 3.3575 generated text: this movie is the kind of movie you will not be disappointed . it 's like an [UNK] [UNK] , who is a movie . it 's a great story and the characters are great , the actors are good , their [UNK] , Epoch 24/25 391/391 - 134s - loss: 3.3372 - dense_2_loss: 3.3372 generated text: this movie is a classic 80s horror movie . this has a great premise and the characters is a bit too typical [UNK] and [UNK] \" with the [UNK] \" . it 's all that makes sense . the characters were shallow and unrealistic Epoch 25/25 391/391 - 134s - loss: 3.3182 - dense_2_loss: 3.3182 generated text: this movie is not the worst movie i have ever seen . it 's a movie where i 've never seen it before and i 've seen it again and again , again , i can 't believe it was made in a theatre Convolutional Variational AutoEncoder (VAE) trained on MNIST digits. Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Create a sampling layer class Sampling(layers.Layer): \"\"\"Uses (z_mean, z_log_var) to sample z, the vector encoding a digit.\"\"\" def call(self, inputs): z_mean, z_log_var = inputs batch = tf.shape(z_mean)[0] dim = tf.shape(z_mean)[1] epsilon = tf.keras.backend.random_normal(shape=(batch, dim)) return z_mean + tf.exp(0.5 * z_log_var) * epsilon Build the encoder latent_dim = 2 encoder_inputs = keras.Input(shape=(28, 28, 1)) x = layers.Conv2D(32, 3, activation=\"relu\", strides=2, padding=\"same\")(encoder_inputs) x = layers.Conv2D(64, 3, activation=\"relu\", strides=2, padding=\"same\")(x) x = layers.Flatten()(x) x = layers.Dense(16, activation=\"relu\")(x) z_mean = layers.Dense(latent_dim, name=\"z_mean\")(x) z_log_var = layers.Dense(latent_dim, name=\"z_log_var\")(x) z = Sampling()([z_mean, z_log_var]) encoder = keras.Model(encoder_inputs, [z_mean, z_log_var, z], name=\"encoder\") encoder.summary() Model: \"encoder\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 28, 28, 1)] 0 __________________________________________________________________________________________________ conv2d (Conv2D) (None, 14, 14, 32) 320 input_1[0][0] __________________________________________________________________________________________________ conv2d_1 (Conv2D) (None, 7, 7, 64) 18496 conv2d[0][0] __________________________________________________________________________________________________ flatten (Flatten) (None, 3136) 0 conv2d_1[0][0] __________________________________________________________________________________________________ dense (Dense) (None, 16) 50192 flatten[0][0] __________________________________________________________________________________________________ z_mean (Dense) (None, 2) 34 dense[0][0] __________________________________________________________________________________________________ z_log_var (Dense) (None, 2) 34 dense[0][0] __________________________________________________________________________________________________ sampling (Sampling) (None, 2) 0 z_mean[0][0] z_log_var[0][0] ================================================================================================== Total params: 69,076 Trainable params: 69,076 Non-trainable params: 0 __________________________________________________________________________________________________ Build the decoder latent_inputs = keras.Input(shape=(latent_dim,)) x = layers.Dense(7 * 7 * 64, activation=\"relu\")(latent_inputs) x = layers.Reshape((7, 7, 64))(x) x = layers.Conv2DTranspose(64, 3, activation=\"relu\", strides=2, padding=\"same\")(x) x = layers.Conv2DTranspose(32, 3, activation=\"relu\", strides=2, padding=\"same\")(x) decoder_outputs = layers.Conv2DTranspose(1, 3, activation=\"sigmoid\", padding=\"same\")(x) decoder = keras.Model(latent_inputs, decoder_outputs, name=\"decoder\") decoder.summary() Model: \"decoder\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) [(None, 2)] 0 _________________________________________________________________ dense_1 (Dense) (None, 3136) 9408 _________________________________________________________________ reshape (Reshape) (None, 7, 7, 64) 0 _________________________________________________________________ conv2d_transpose (Conv2DTran (None, 14, 14, 64) 36928 _________________________________________________________________ conv2d_transpose_1 (Conv2DTr (None, 28, 28, 32) 18464 _________________________________________________________________ conv2d_transpose_2 (Conv2DTr (None, 28, 28, 1) 289 ================================================================= Total params: 65,089 Trainable params: 65,089 Non-trainable params: 0 _________________________________________________________________ Define the VAE as a Model with a custom train_step class VAE(keras.Model): def __init__(self, encoder, decoder, **kwargs): super(VAE, self).__init__(**kwargs) self.encoder = encoder self.decoder = decoder self.total_loss_tracker = keras.metrics.Mean(name=\"total_loss\") self.reconstruction_loss_tracker = keras.metrics.Mean( name=\"reconstruction_loss\" ) self.kl_loss_tracker = keras.metrics.Mean(name=\"kl_loss\") @property def metrics(self): return [ self.total_loss_tracker, self.reconstruction_loss_tracker, self.kl_loss_tracker, ] def train_step(self, data): with tf.GradientTape() as tape: z_mean, z_log_var, z = self.encoder(data) reconstruction = self.decoder(z) reconstruction_loss = tf.reduce_mean( tf.reduce_sum( keras.losses.binary_crossentropy(data, reconstruction), axis=(1, 2) ) ) kl_loss = -0.5 * (1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var)) kl_loss = tf.reduce_mean(tf.reduce_sum(kl_loss, axis=1)) total_loss = reconstruction_loss + kl_loss grads = tape.gradient(total_loss, self.trainable_weights) self.optimizer.apply_gradients(zip(grads, self.trainable_weights)) self.total_loss_tracker.update_state(total_loss) self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.kl_loss_tracker.update_state(kl_loss) return { \"loss\": self.total_loss_tracker.result(), \"reconstruction_loss\": self.reconstruction_loss_tracker.result(), \"kl_loss\": self.kl_loss_tracker.result(), } Train the VAE (x_train, _), (x_test, _) = keras.datasets.mnist.load_data() mnist_digits = np.concatenate([x_train, x_test], axis=0) mnist_digits = np.expand_dims(mnist_digits, -1).astype(\"float32\") / 255 vae = VAE(encoder, decoder) vae.compile(optimizer=keras.optimizers.Adam()) vae.fit(mnist_digits, epochs=30, batch_size=128) Epoch 1/30 547/547 [==============================] - 35s 62ms/step - loss: 255.8020 - reconstruction_loss: 208.5391 - kl_loss: 2.9673 Epoch 2/30 547/547 [==============================] - 38s 69ms/step - loss: 178.8786 - reconstruction_loss: 168.4294 - kl_loss: 5.4217 Epoch 3/30 547/547 [==============================] - 39s 72ms/step - loss: 166.0320 - reconstruction_loss: 158.7979 - kl_loss: 5.8015 Epoch 4/30 547/547 [==============================] - 38s 69ms/step - loss: 161.1647 - reconstruction_loss: 154.5963 - kl_loss: 5.9926 Epoch 5/30 547/547 [==============================] - 40s 72ms/step - loss: 152.0941 - reconstruction_loss: 145.7407 - kl_loss: 6.4654 Epoch 14/30 547/547 [==============================] - 38s 70ms/step - loss: 148.8709 - reconstruction_loss: 142.5713 - kl_loss: 6.6179 Epoch 27/30 191/547 [=========>....................] - ETA: 25s - loss: 149.0829 - reconstruction_loss: 142.2507 - kl_loss: 6.6429 Display a grid of sampled digits import matplotlib.pyplot as plt def plot_latent_space(vae, n=30, figsize=15): # display a n*n 2D manifold of digits digit_size = 28 scale = 1.0 figure = np.zeros((digit_size * n, digit_size * n)) # linearly spaced coordinates corresponding to the 2D plot # of digit classes in the latent space grid_x = np.linspace(-scale, scale, n) grid_y = np.linspace(-scale, scale, n)[::-1] for i, yi in enumerate(grid_y): for j, xi in enumerate(grid_x): z_sample = np.array([[xi, yi]]) x_decoded = vae.decoder.predict(z_sample) digit = x_decoded[0].reshape(digit_size, digit_size) figure[ i * digit_size : (i + 1) * digit_size, j * digit_size : (j + 1) * digit_size, ] = digit plt.figure(figsize=(figsize, figsize)) start_range = digit_size // 2 end_range = n * digit_size + start_range pixel_range = np.arange(start_range, end_range, digit_size) sample_range_x = np.round(grid_x, 1) sample_range_y = np.round(grid_y, 1) plt.xticks(pixel_range, sample_range_x) plt.yticks(pixel_range, sample_range_y) plt.xlabel(\"z[0]\") plt.ylabel(\"z[1]\") plt.imshow(figure, cmap=\"Greys_r\") plt.show() plot_latent_space(vae) png Display how the latent space clusters different digit classes def plot_label_clusters(vae, data, labels): # display a 2D plot of the digit classes in the latent space z_mean, _, _ = vae.encoder.predict(data) plt.figure(figsize=(12, 10)) plt.scatter(z_mean[:, 0], z_mean[:, 1], c=labels) plt.colorbar() plt.xlabel(\"z[0]\") plt.ylabel(\"z[1]\") plt.show() (x_train, y_train), _ = keras.datasets.mnist.load_data() x_train = np.expand_dims(x_train, -1).astype(\"float32\") / 255 plot_label_clusters(vae, x_train, y_train) png Training a VQ-VAE for image reconstruction and codebook sampling for generation. In this example, we will develop a Vector Quantized Variational Autoencoder (VQ-VAE). VQ-VAE was proposed in Neural Discrete Representation Learning by van der Oord et al. In traditional VAEs, the latent space is continuous and is sampled from a Gaussian distribution. It is generally harder to learn such a continuous distribution via gradient descent. VQ-VAEs, on the other hand, operate on a discrete latent space, making the optimization problem simpler. It does so by maintaining a discrete codebook. The codebook is developed by discretizing the distance between continuous embeddings and the encoded outputs. These discrete code words are then fed to the decoder, which is trained to generate reconstructed samples. For a detailed overview of VQ-VAEs, please refer to the original paper and this video explanation. If you need a refresher on VAEs, you can refer to this book chapter. VQ-VAEs are one of the main recipes behind DALL-E and the idea of a codebook is used in VQ-GANs. This example uses references from the official VQ-VAE tutorial from DeepMind. To run this example, you will need TensorFlow 2.5 or higher, as well as TensorFlow Probability, which can be installed using the command below. !pip install -q tensorflow-probability Imports import numpy as np import matplotlib.pyplot as plt from tensorflow import keras from tensorflow.keras import layers import tensorflow_probability as tfp import tensorflow as tf VectorQuantizer layer Here, we will implement a custom layer to encapsulate the vector quantizer logic, which is the central component of VQ-VAEs. Consider an output from the encoder, with shape (batch_size, height, width, num_channels). The vector quantizer will first flatten this output, only keeping the num_channels dimension intact. So, the shape would become (batch_size * height * width, num_channels). The rationale behind this is to treat the total number of channels as the space for the latent embeddings. An embedding table is then initialized to learn a codebook. We measure the L2-normalized distance between the flattened encoder outputs and code words of this codebook. We take the code that yields the minimum distance, and we apply one-hot encoding to achieve quantization. This way, the code yielding the minimum distance to the corresponding encoder output is mapped as one and the remaining codes are mapped as zeros. Since the quantization process is not differentiable, we apply a straight-through estimator in between the decoder and the encoder, so that the decoder gradients are directly propagated to the encoder. As the encoder and decoder share the same channel space, the hope is that the decoder gradients will still be meaningful to the encoder. class VectorQuantizer(layers.Layer): def __init__(self, num_embeddings, embedding_dim, beta=0.25, **kwargs): super().__init__(**kwargs) self.embedding_dim = embedding_dim self.num_embeddings = num_embeddings self.beta = ( beta # This parameter is best kept between [0.25, 2] as per the paper. ) # Initialize the embeddings which we will quantize. w_init = tf.random_uniform_initializer() self.embeddings = tf.Variable( initial_value=w_init( shape=(self.embedding_dim, self.num_embeddings), dtype=\"float32\" ), trainable=True, name=\"embeddings_vqvae\", ) def call(self, x): # Calculate the input shape of the inputs and # then flatten the inputs keeping `embedding_dim` intact. input_shape = tf.shape(x) flattened = tf.reshape(x, [-1, self.embedding_dim]) # Quantization. encoding_indices = self.get_code_indices(flattened) encodings = tf.one_hot(encoding_indices, self.num_embeddings) quantized = tf.matmul(encodings, self.embeddings, transpose_b=True) quantized = tf.reshape(quantized, input_shape) # Calculate vector quantization loss and add that to the layer. You can learn more # about adding losses to different layers here: # https://keras.io/guides/making_new_layers_and_models_via_subclassing/. Check # the original paper to get a handle on the formulation of the loss function. commitment_loss = self.beta * tf.reduce_mean( (tf.stop_gradient(quantized) - x) ** 2 ) codebook_loss = tf.reduce_mean((quantized - tf.stop_gradient(x)) ** 2) self.add_loss(commitment_loss + codebook_loss) # Straight-through estimator. quantized = x + tf.stop_gradient(quantized - x) return quantized def get_code_indices(self, flattened_inputs): # Calculate L2-normalized distance between the inputs and the codes. similarity = tf.matmul(flattened_inputs, self.embeddings) distances = ( tf.reduce_sum(flattened_inputs ** 2, axis=1, keepdims=True) + tf.reduce_sum(self.embeddings ** 2, axis=0) - 2 * similarity ) # Derive the indices for minimum distances. encoding_indices = tf.argmin(distances, axis=1) return encoding_indices A note on straight-through estimation: This line of code does the straight-through estimation part: quantized = x + tf.stop_gradient(quantized - x). During backpropagation, (quantized - x) won't be included in the computation graph and th gradients obtaind for quantized will be copied for inputs. Thanks to this video for helping me understand this technique. Encoder and decoder We will now implement the encoder and the decoder for the VQ-VAE. We will keep them small so that their capacity is a good fit for the MNIST dataset, which we will use to demonstrate the results. The definitions of the encoder and decoder come from this example. def get_encoder(latent_dim=16): encoder_inputs = keras.Input(shape=(28, 28, 1)) x = layers.Conv2D(32, 3, activation=\"relu\", strides=2, padding=\"same\")( encoder_inputs ) x = layers.Conv2D(64, 3, activation=\"relu\", strides=2, padding=\"same\")(x) encoder_outputs = layers.Conv2D(latent_dim, 1, padding=\"same\")(x) return keras.Model(encoder_inputs, encoder_outputs, name=\"encoder\") def get_decoder(latent_dim=16): latent_inputs = keras.Input(shape=get_encoder().output.shape[1:]) x = layers.Conv2DTranspose(64, 3, activation=\"relu\", strides=2, padding=\"same\")( latent_inputs ) x = layers.Conv2DTranspose(32, 3, activation=\"relu\", strides=2, padding=\"same\")(x) decoder_outputs = layers.Conv2DTranspose(1, 3, padding=\"same\")(x) return keras.Model(latent_inputs, decoder_outputs, name=\"decoder\") Standalone VQ-VAE model def get_vqvae(latent_dim=16, num_embeddings=64): vq_layer = VectorQuantizer(num_embeddings, latent_dim, name=\"vector_quantizer\") encoder = get_encoder(latent_dim) decoder = get_decoder(latent_dim) inputs = keras.Input(shape=(28, 28, 1)) encoder_outputs = encoder(inputs) quantized_latents = vq_layer(encoder_outputs) reconstructions = decoder(quantized_latents) return keras.Model(inputs, reconstructions, name=\"vq_vae\") get_vqvae().summary() Model: \"vq_vae\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_4 (InputLayer) [(None, 28, 28, 1)] 0 _________________________________________________________________ encoder (Functional) (None, 7, 7, 16) 19856 _________________________________________________________________ vector_quantizer (VectorQuan (None, 7, 7, 16) 1024 _________________________________________________________________ decoder (Functional) (None, 28, 28, 1) 28033 ================================================================= Total params: 48,913 Trainable params: 48,913 Non-trainable params: 0 _________________________________________________________________ Note that the output channels of the encoder should match the latent_dim for the vector quantizer. Wrapping up the training loop inside VQVAETrainer class VQVAETrainer(keras.models.Model): def __init__(self, train_variance, latent_dim=32, num_embeddings=128, **kwargs): super(VQVAETrainer, self).__init__(**kwargs) self.train_variance = train_variance self.latent_dim = latent_dim self.num_embeddings = num_embeddings self.vqvae = get_vqvae(self.latent_dim, self.num_embeddings) self.total_loss_tracker = keras.metrics.Mean(name=\"total_loss\") self.reconstruction_loss_tracker = keras.metrics.Mean( name=\"reconstruction_loss\" ) self.vq_loss_tracker = keras.metrics.Mean(name=\"vq_loss\") @property def metrics(self): return [ self.total_loss_tracker, self.reconstruction_loss_tracker, self.vq_loss_tracker, ] def train_step(self, x): with tf.GradientTape() as tape: # Outputs from the VQ-VAE. reconstructions = self.vqvae(x) # Calculate the losses. reconstruction_loss = ( tf.reduce_mean((x - reconstructions) ** 2) / self.train_variance ) total_loss = reconstruction_loss + sum(self.vqvae.losses) # Backpropagation. grads = tape.gradient(total_loss, self.vqvae.trainable_variables) self.optimizer.apply_gradients(zip(grads, self.vqvae.trainable_variables)) # Loss tracking. self.total_loss_tracker.update_state(total_loss) self.reconstruction_loss_tracker.update_state(reconstruction_loss) self.vq_loss_tracker.update_state(sum(self.vqvae.losses)) # Log results. return { \"loss\": self.total_loss_tracker.result(), \"reconstruction_loss\": self.reconstruction_loss_tracker.result(), \"vqvae_loss\": self.vq_loss_tracker.result(), } Load and preprocess the MNIST dataset (x_train, _), (x_test, _) = keras.datasets.mnist.load_data() x_train = np.expand_dims(x_train, -1) x_test = np.expand_dims(x_test, -1) x_train_scaled = (x_train / 255.0) - 0.5 x_test_scaled = (x_test / 255.0) - 0.5 data_variance = np.var(x_train / 255.0) Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz 11493376/11490434 [==============================] - 0s 0us/step Train the VQ-VAE model vqvae_trainer = VQVAETrainer(data_variance, latent_dim=16, num_embeddings=128) vqvae_trainer.compile(optimizer=keras.optimizers.Adam()) vqvae_trainer.fit(x_train_scaled, epochs=30, batch_size=128) Epoch 1/30 469/469 [==============================] - 18s 6ms/step - loss: 2.2962 - reconstruction_loss: 0.3869 - vqvae_loss: 1.5950 Epoch 2/30 469/469 [==============================] - 3s 6ms/step - loss: 2.2980 - reconstruction_loss: 0.1692 - vqvae_loss: 2.1108 Epoch 3/30 469/469 [==============================] - 3s 6ms/step - loss: 1.1356 - reconstruction_loss: 0.1281 - vqvae_loss: 0.9997 Epoch 4/30 469/469 [==============================] - 3s 6ms/step - loss: 0.6112 - reconstruction_loss: 0.1030 - vqvae_loss: 0.5031 Epoch 5/30 469/469 [==============================] - 3s 6ms/step - loss: 0.4375 - reconstruction_loss: 0.0883 - vqvae_loss: 0.3464 Epoch 6/30 469/469 [==============================] - 3s 6ms/step - loss: 0.3579 - reconstruction_loss: 0.0788 - vqvae_loss: 0.2775 Epoch 7/30 469/469 [==============================] - 3s 5ms/step - loss: 0.3197 - reconstruction_loss: 0.0725 - vqvae_loss: 0.2457 Epoch 8/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2960 - reconstruction_loss: 0.0673 - vqvae_loss: 0.2277 Epoch 9/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2798 - reconstruction_loss: 0.0640 - vqvae_loss: 0.2152 Epoch 10/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2681 - reconstruction_loss: 0.0612 - vqvae_loss: 0.2061 Epoch 11/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2578 - reconstruction_loss: 0.0590 - vqvae_loss: 0.1986 Epoch 12/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2551 - reconstruction_loss: 0.0574 - vqvae_loss: 0.1974 Epoch 13/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2526 - reconstruction_loss: 0.0560 - vqvae_loss: 0.1961 Epoch 14/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2485 - reconstruction_loss: 0.0546 - vqvae_loss: 0.1936 Epoch 15/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2462 - reconstruction_loss: 0.0533 - vqvae_loss: 0.1926 Epoch 16/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2445 - reconstruction_loss: 0.0523 - vqvae_loss: 0.1920 Epoch 17/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2427 - reconstruction_loss: 0.0515 - vqvae_loss: 0.1911 Epoch 18/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2405 - reconstruction_loss: 0.0505 - vqvae_loss: 0.1898 Epoch 19/30 469/469 [==============================] - 3s 6ms/step - loss: 0.2368 - reconstruction_loss: 0.0495 - vqvae_loss: 0.1871 Epoch 20/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2310 - reconstruction_loss: 0.0486 - vqvae_loss: 0.1822 Epoch 21/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2245 - reconstruction_loss: 0.0475 - vqvae_loss: 0.1769 Epoch 22/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2205 - reconstruction_loss: 0.0469 - vqvae_loss: 0.1736 Epoch 23/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2195 - reconstruction_loss: 0.0465 - vqvae_loss: 0.1730 Epoch 24/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2187 - reconstruction_loss: 0.0461 - vqvae_loss: 0.1726 Epoch 25/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2180 - reconstruction_loss: 0.0458 - vqvae_loss: 0.1721 Epoch 26/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2163 - reconstruction_loss: 0.0454 - vqvae_loss: 0.1709 Epoch 27/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2156 - reconstruction_loss: 0.0452 - vqvae_loss: 0.1704 Epoch 28/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2146 - reconstruction_loss: 0.0449 - vqvae_loss: 0.1696 Epoch 29/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2139 - reconstruction_loss: 0.0447 - vqvae_loss: 0.1692 Epoch 30/30 469/469 [==============================] - 3s 5ms/step - loss: 0.2127 - reconstruction_loss: 0.0444 - vqvae_loss: 0.1682 Reconstruction results on the test set def show_subplot(original, reconstructed): plt.subplot(1, 2, 1) plt.imshow(original.squeeze() + 0.5) plt.title(\"Original\") plt.axis(\"off\") plt.subplot(1, 2, 2) plt.imshow(reconstructed.squeeze() + 0.5) plt.title(\"Reconstructed\") plt.axis(\"off\") plt.show() trained_vqvae_model = vqvae_trainer.vqvae idx = np.random.choice(len(x_test_scaled), 10) test_images = x_test_scaled[idx] reconstructions_test = trained_vqvae_model.predict(test_images) for test_image, reconstructed_image in zip(test_images, reconstructions_test): show_subplot(test_image, reconstructed_image) png png png png png png png png png png These results look decent. You are encouraged to play with different hyperparameters (especially the number of embeddings and the dimensions of the embeddings) and observe how they affect the results. Visualizing the discrete codes encoder = vqvae_trainer.vqvae.get_layer(\"encoder\") quantizer = vqvae_trainer.vqvae.get_layer(\"vector_quantizer\") encoded_outputs = encoder.predict(test_images) flat_enc_outputs = encoded_outputs.reshape(-1, encoded_outputs.shape[-1]) codebook_indices = quantizer.get_code_indices(flat_enc_outputs) codebook_indices = codebook_indices.numpy().reshape(encoded_outputs.shape[:-1]) for i in range(len(test_images)): plt.subplot(1, 2, 1) plt.imshow(test_images[i].squeeze() + 0.5) plt.title(\"Original\") plt.axis(\"off\") plt.subplot(1, 2, 2) plt.imshow(codebook_indices[i]) plt.title(\"Code\") plt.axis(\"off\") plt.show() png png png png png png png png png png The figure above shows that the discrete codes have been able to capture some regularities from the dataset. Now, you might wonder, how do we use these codes to generate new samples? Specifically, how do we sample from this codebook to create novel examples? Since these codes are discrete and we imposed a categorical distribution on them, we cannot use them yet to generate anything meaningful. These codes were not updated during the training process as well. So, they need to be adjusted further so that we can use for them the subsequent image generation task. The authors use a PixelCNN to train these codes so that they can be used as powerful priors to generate novel examples. PixelCNN was proposed in Conditional Image Generation with PixelCNN Decoders by van der Oord et al. We will borrow code from this example to develop a PixelCNN. It's an auto-regressive generative model where the current outputs are conditioned on the prior ones. In other words, a PixelCNN generates an image on a pixel-by-pixel basis. PixelCNN hyperparameters num_residual_blocks = 2 num_pixelcnn_layers = 2 pixelcnn_input_shape = encoded_outputs.shape[1:-1] print(f\"Input shape of the PixelCNN: {pixelcnn_input_shape}\") Input shape of the PixelCNN: (7, 7) Don't worry about the input shape. It'll become clear in the following sections. PixelCNN model Majority of this comes from this example. # The first layer is the PixelCNN layer. This layer simply # builds on the 2D convolutional layer, but includes masking. class PixelConvLayer(layers.Layer): def __init__(self, mask_type, **kwargs): super(PixelConvLayer, self).__init__() self.mask_type = mask_type self.conv = layers.Conv2D(**kwargs) def build(self, input_shape): # Build the conv2d layer to initialize kernel variables self.conv.build(input_shape) # Use the initialized kernel to create the mask kernel_shape = self.conv.kernel.get_shape() self.mask = np.zeros(shape=kernel_shape) self.mask[: kernel_shape[0] // 2, ...] = 1.0 self.mask[kernel_shape[0] // 2, : kernel_shape[1] // 2, ...] = 1.0 if self.mask_type == \"B\": self.mask[kernel_shape[0] // 2, kernel_shape[1] // 2, ...] = 1.0 def call(self, inputs): self.conv.kernel.assign(self.conv.kernel * self.mask) return self.conv(inputs) # Next, we build our residual block layer. # This is just a normal residual block, but based on the PixelConvLayer. class ResidualBlock(keras.layers.Layer): def __init__(self, filters, **kwargs): super(ResidualBlock, self).__init__(**kwargs) self.conv1 = keras.layers.Conv2D( filters=filters, kernel_size=1, activation=\"relu\" ) self.pixel_conv = PixelConvLayer( mask_type=\"B\", filters=filters // 2, kernel_size=3, activation=\"relu\", padding=\"same\", ) self.conv2 = keras.layers.Conv2D( filters=filters, kernel_size=1, activation=\"relu\" ) def call(self, inputs): x = self.conv1(inputs) x = self.pixel_conv(x) x = self.conv2(x) return keras.layers.add([inputs, x]) pixelcnn_inputs = keras.Input(shape=pixelcnn_input_shape, dtype=tf.int32) ohe = tf.one_hot(pixelcnn_inputs, vqvae_trainer.num_embeddings) x = PixelConvLayer( mask_type=\"A\", filters=128, kernel_size=7, activation=\"relu\", padding=\"same\" )(ohe) for _ in range(num_residual_blocks): x = ResidualBlock(filters=128)(x) for _ in range(num_pixelcnn_layers): x = PixelConvLayer( mask_type=\"B\", filters=128, kernel_size=1, strides=1, activation=\"relu\", padding=\"valid\", )(x) out = keras.layers.Conv2D( filters=vqvae_trainer.num_embeddings, kernel_size=1, strides=1, padding=\"valid\" )(x) pixel_cnn = keras.Model(pixelcnn_inputs, out, name=\"pixel_cnn\") pixel_cnn.summary() Model: \"pixel_cnn\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_9 (InputLayer) [(None, 7, 7)] 0 _________________________________________________________________ tf.one_hot (TFOpLambda) (None, 7, 7, 128) 0 _________________________________________________________________ pixel_conv_layer (PixelConvL (None, 7, 7, 128) 802944 _________________________________________________________________ residual_block (ResidualBloc (None, 7, 7, 128) 98624 _________________________________________________________________ residual_block_1 (ResidualBl (None, 7, 7, 128) 98624 _________________________________________________________________ pixel_conv_layer_3 (PixelCon (None, 7, 7, 128) 16512 _________________________________________________________________ pixel_conv_layer_4 (PixelCon (None, 7, 7, 128) 16512 _________________________________________________________________ conv2d_21 (Conv2D) (None, 7, 7, 128) 16512 ================================================================= Total params: 1,049,728 Trainable params: 1,049,728 Non-trainable params: 0 _________________________________________________________________ Prepare data to train the PixelCNN We will train the PixelCNN to learn a categorical distribution of the discrete codes. First, we will generate code indices using the encoder and vector quantizer we just trained. Our training objective will be to minimize the crossentropy loss between these indices and the PixelCNN outputs. Here, the number of categories is equal to the number of embeddings present in our codebook (128 in our case). The PixelCNN model is trained to learn a distribution (as opposed to minimizing the L1/L2 loss), which is where it gets its generative capabilities from. # Generate the codebook indices. encoded_outputs = encoder.predict(x_train_scaled) flat_enc_outputs = encoded_outputs.reshape(-1, encoded_outputs.shape[-1]) codebook_indices = quantizer.get_code_indices(flat_enc_outputs) codebook_indices = codebook_indices.numpy().reshape(encoded_outputs.shape[:-1]) print(f\"Shape of the training data for PixelCNN: {codebook_indices.shape}\") Shape of the training data for PixelCNN: (60000, 7, 7) PixelCNN training pixel_cnn.compile( optimizer=keras.optimizers.Adam(3e-4), loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[\"accuracy\"], ) pixel_cnn.fit( x=codebook_indices, y=codebook_indices, batch_size=128, epochs=30, validation_split=0.1, ) Epoch 1/30 422/422 [==============================] - 4s 8ms/step - loss: 1.8550 - accuracy: 0.5959 - val_loss: 1.3127 - val_accuracy: 0.6268 Epoch 2/30 422/422 [==============================] - 3s 7ms/step - loss: 1.2207 - accuracy: 0.6402 - val_loss: 1.1722 - val_accuracy: 0.6482 Epoch 3/30 422/422 [==============================] - 3s 7ms/step - loss: 1.1412 - accuracy: 0.6536 - val_loss: 1.1313 - val_accuracy: 0.6552 Epoch 4/30 422/422 [==============================] - 3s 7ms/step - loss: 1.1060 - accuracy: 0.6601 - val_loss: 1.1058 - val_accuracy: 0.6596 Epoch 5/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0828 - accuracy: 0.6646 - val_loss: 1.1020 - val_accuracy: 0.6603 Epoch 6/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0649 - accuracy: 0.6682 - val_loss: 1.0809 - val_accuracy: 0.6638 Epoch 7/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0515 - accuracy: 0.6710 - val_loss: 1.0712 - val_accuracy: 0.6659 Epoch 8/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0406 - accuracy: 0.6733 - val_loss: 1.0647 - val_accuracy: 0.6671 Epoch 9/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0312 - accuracy: 0.6752 - val_loss: 1.0633 - val_accuracy: 0.6674 Epoch 10/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0235 - accuracy: 0.6771 - val_loss: 1.0554 - val_accuracy: 0.6695 Epoch 11/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0162 - accuracy: 0.6788 - val_loss: 1.0518 - val_accuracy: 0.6694 Epoch 12/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0105 - accuracy: 0.6799 - val_loss: 1.0541 - val_accuracy: 0.6693 Epoch 13/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0050 - accuracy: 0.6811 - val_loss: 1.0481 - val_accuracy: 0.6705 Epoch 14/30 422/422 [==============================] - 3s 7ms/step - loss: 1.0011 - accuracy: 0.6820 - val_loss: 1.0462 - val_accuracy: 0.6709 Epoch 15/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9964 - accuracy: 0.6831 - val_loss: 1.0459 - val_accuracy: 0.6709 Epoch 16/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9922 - accuracy: 0.6840 - val_loss: 1.0444 - val_accuracy: 0.6704 Epoch 17/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9884 - accuracy: 0.6848 - val_loss: 1.0405 - val_accuracy: 0.6725 Epoch 18/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9846 - accuracy: 0.6859 - val_loss: 1.0400 - val_accuracy: 0.6722 Epoch 19/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9822 - accuracy: 0.6864 - val_loss: 1.0394 - val_accuracy: 0.6728 Epoch 20/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9787 - accuracy: 0.6872 - val_loss: 1.0393 - val_accuracy: 0.6717 Epoch 21/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9761 - accuracy: 0.6878 - val_loss: 1.0398 - val_accuracy: 0.6725 Epoch 22/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9733 - accuracy: 0.6884 - val_loss: 1.0376 - val_accuracy: 0.6726 Epoch 23/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9708 - accuracy: 0.6890 - val_loss: 1.0352 - val_accuracy: 0.6732 Epoch 24/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9685 - accuracy: 0.6894 - val_loss: 1.0369 - val_accuracy: 0.6723 Epoch 25/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9660 - accuracy: 0.6901 - val_loss: 1.0384 - val_accuracy: 0.6733 Epoch 26/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9638 - accuracy: 0.6908 - val_loss: 1.0355 - val_accuracy: 0.6728 Epoch 27/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9619 - accuracy: 0.6912 - val_loss: 1.0325 - val_accuracy: 0.6739 Epoch 28/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9594 - accuracy: 0.6917 - val_loss: 1.0334 - val_accuracy: 0.6736 Epoch 29/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9582 - accuracy: 0.6920 - val_loss: 1.0366 - val_accuracy: 0.6733 Epoch 30/30 422/422 [==============================] - 3s 7ms/step - loss: 0.9561 - accuracy: 0.6926 - val_loss: 1.0336 - val_accuracy: 0.6728 We can improve these scores with more training and hyperparameter tuning. Codebook sampling Now that our PixelCNN is trained, we can sample distinct codes from its outputs and pass them to our decoder to generate novel images. # Create a mini sampler model. inputs = layers.Input(shape=pixel_cnn.input_shape[1:]) x = pixel_cnn(inputs, training=False) dist = tfp.distributions.Categorical(logits=x) sampled = dist.sample() sampler = keras.Model(inputs, sampled) We now construct a prior to generate images. Here, we will generate 10 images. # Create an empty array of priors. batch = 10 priors = np.zeros(shape=(batch,) + (pixel_cnn.input_shape)[1:]) batch, rows, cols = priors.shape # Iterate over the priors because generation has to be done sequentially pixel by pixel. for row in range(rows): for col in range(cols): # Feed the whole array and retrieving the pixel value probabilities for the next # pixel. probs = sampler.predict(priors) # Use the probabilities to pick pixel values and append the values to the priors. priors[:, row, col] = probs[:, row, col] print(f\"Prior shape: {priors.shape}\") Prior shape: (10, 7, 7) We can now use our decoder to generate the images. # Perform an embedding lookup. pretrained_embeddings = quantizer.embeddings priors_ohe = tf.one_hot(priors.astype(\"int32\"), vqvae_trainer.num_embeddings).numpy() quantized = tf.matmul( priors_ohe.astype(\"float32\"), pretrained_embeddings, transpose_b=True ) quantized = tf.reshape(quantized, (-1, *(encoded_outputs.shape[1:]))) # Generate novel images. decoder = vqvae_trainer.vqvae.get_layer(\"decoder\") generated_samples = decoder.predict(quantized) for i in range(batch): plt.subplot(1, 2, 1) plt.imshow(priors[i]) plt.title(\"Code\") plt.axis(\"off\") plt.subplot(1, 2, 2) plt.imshow(generated_samples[i].squeeze() + 0.5) plt.title(\"Generated Sample\") plt.axis(\"off\") plt.show() png png png png png png png png png png We can enhance the quality of these generated samples by tweaking the PixelCNN. Additional notes After the VQ-VAE paper was initially released, the authors developed an exponential moving averaging scheme to update the embeddings inside the quantizer. If you're interested you can check out this snippet. To further enhance the quality of the generated samples, VQ-VAE-2 was proposed that follows a cascaded approach to learn the codebook and to generate the images. Implementation of Wasserstein GAN with Gradient Penalty. Wasserstein GAN (WGAN) with Gradient Penalty (GP) The original Wasserstein GAN leverages the Wasserstein distance to produce a value function that has better theoretical properties than the value function used in the original GAN paper. WGAN requires that the discriminator (aka the critic) lie within the space of 1-Lipschitz functions. The authors proposed the idea of weight clipping to achieve this constraint. Though weight clipping works, it can be a problematic way to enforce 1-Lipschitz constraint and can cause undesirable behavior, e.g. a very deep WGAN discriminator (critic) often fails to converge. The WGAN-GP method proposes an alternative to weight clipping to ensure smooth training. Instead of clipping the weights, the authors proposed a \"gradient penalty\" by adding a loss term that keeps the L2 norm of the discriminator gradients close to 1. Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Prepare the Fashion-MNIST data To demonstrate how to train WGAN-GP, we will be using the Fashion-MNIST dataset. Each sample in this dataset is a 28x28 grayscale image associated with a label from 10 classes (e.g. trouser, pullover, sneaker, etc.) IMG_SHAPE = (28, 28, 1) BATCH_SIZE = 512 # Size of the noise vector noise_dim = 128 fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data() print(f\"Number of examples: {len(train_images)}\") print(f\"Shape of the images in the dataset: {train_images.shape[1:]}\") # Reshape each sample to (28, 28, 1) and normalize the pixel values in the [-1, 1] range train_images = train_images.reshape(train_images.shape[0], *IMG_SHAPE).astype(\"float32\") train_images = (train_images - 127.5) / 127.5 Number of examples: 60000 Shape of the images in the dataset: (28, 28) Create the discriminator (the critic in the original WGAN) The samples in the dataset have a (28, 28, 1) shape. Because we will be using strided convolutions, this can result in a shape with odd dimensions. For example, (28, 28) -> Conv_s2 -> (14, 14) -> Conv_s2 -> (7, 7) -> Conv_s2 ->(3, 3). While peforming upsampling in the generator part of the network, we won't get the same input shape as the original images if we aren't careful. To avoid this, we will do something much simpler: - In the discriminator: \"zero pad\" the input to change the shape to (32, 32, 1) for each sample; and - Ihe generator: crop the final output to match the shape with input shape. def conv_block( x, filters, activation, kernel_size=(3, 3), strides=(1, 1), padding=\"same\", use_bias=True, use_bn=False, use_dropout=False, drop_value=0.5, ): x = layers.Conv2D( filters, kernel_size, strides=strides, padding=padding, use_bias=use_bias )(x) if use_bn: x = layers.BatchNormalization()(x) x = activation(x) if use_dropout: x = layers.Dropout(drop_value)(x) return x def get_discriminator_model(): img_input = layers.Input(shape=IMG_SHAPE) # Zero pad the input to make the input images size to (32, 32, 1). x = layers.ZeroPadding2D((2, 2))(img_input) x = conv_block( x, 64, kernel_size=(5, 5), strides=(2, 2), use_bn=False, use_bias=True, activation=layers.LeakyReLU(0.2), use_dropout=False, drop_value=0.3, ) x = conv_block( x, 128, kernel_size=(5, 5), strides=(2, 2), use_bn=False, activation=layers.LeakyReLU(0.2), use_bias=True, use_dropout=True, drop_value=0.3, ) x = conv_block( x, 256, kernel_size=(5, 5), strides=(2, 2), use_bn=False, activation=layers.LeakyReLU(0.2), use_bias=True, use_dropout=True, drop_value=0.3, ) x = conv_block( x, 512, kernel_size=(5, 5), strides=(2, 2), use_bn=False, activation=layers.LeakyReLU(0.2), use_bias=True, use_dropout=False, drop_value=0.3, ) x = layers.Flatten()(x) x = layers.Dropout(0.2)(x) x = layers.Dense(1)(x) d_model = keras.models.Model(img_input, x, name=\"discriminator\") return d_model d_model = get_discriminator_model() d_model.summary() Model: \"discriminator\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 28, 28, 1)] 0 _________________________________________________________________ zero_padding2d (ZeroPadding2 (None, 32, 32, 1) 0 _________________________________________________________________ conv2d (Conv2D) (None, 16, 16, 64) 1664 _________________________________________________________________ leaky_re_lu (LeakyReLU) (None, 16, 16, 64) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 8, 8, 128) 204928 _________________________________________________________________ leaky_re_lu_1 (LeakyReLU) (None, 8, 8, 128) 0 _________________________________________________________________ dropout (Dropout) (None, 8, 8, 128) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 4, 4, 256) 819456 _________________________________________________________________ leaky_re_lu_2 (LeakyReLU) (None, 4, 4, 256) 0 _________________________________________________________________ dropout_1 (Dropout) (None, 4, 4, 256) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 2, 2, 512) 3277312 _________________________________________________________________ leaky_re_lu_3 (LeakyReLU) (None, 2, 2, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 2048) 0 _________________________________________________________________ dropout_2 (Dropout) (None, 2048) 0 _________________________________________________________________ dense (Dense) (None, 1) 2049 ================================================================= Total params: 4,305,409 Trainable params: 4,305,409 Non-trainable params: 0 _________________________________________________________________ Create the generator def upsample_block( x, filters, activation, kernel_size=(3, 3), strides=(1, 1), up_size=(2, 2), padding=\"same\", use_bn=False, use_bias=True, use_dropout=False, drop_value=0.3, ): x = layers.UpSampling2D(up_size)(x) x = layers.Conv2D( filters, kernel_size, strides=strides, padding=padding, use_bias=use_bias )(x) if use_bn: x = layers.BatchNormalization()(x) if activation: x = activation(x) if use_dropout: x = layers.Dropout(drop_value)(x) return x def get_generator_model(): noise = layers.Input(shape=(noise_dim,)) x = layers.Dense(4 * 4 * 256, use_bias=False)(noise) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(0.2)(x) x = layers.Reshape((4, 4, 256))(x) x = upsample_block( x, 128, layers.LeakyReLU(0.2), strides=(1, 1), use_bias=False, use_bn=True, padding=\"same\", use_dropout=False, ) x = upsample_block( x, 64, layers.LeakyReLU(0.2), strides=(1, 1), use_bias=False, use_bn=True, padding=\"same\", use_dropout=False, ) x = upsample_block( x, 1, layers.Activation(\"tanh\"), strides=(1, 1), use_bias=False, use_bn=True ) # At this point, we have an output which has the same shape as the input, (32, 32, 1). # We will use a Cropping2D layer to make it (28, 28, 1). x = layers.Cropping2D((2, 2))(x) g_model = keras.models.Model(noise, x, name=\"generator\") return g_model g_model = get_generator_model() g_model.summary() Model: \"generator\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) [(None, 128)] 0 _________________________________________________________________ dense_1 (Dense) (None, 4096) 524288 _________________________________________________________________ batch_normalization (BatchNo (None, 4096) 16384 _________________________________________________________________ leaky_re_lu_4 (LeakyReLU) (None, 4096) 0 _________________________________________________________________ reshape (Reshape) (None, 4, 4, 256) 0 _________________________________________________________________ up_sampling2d (UpSampling2D) (None, 8, 8, 256) 0 _________________________________________________________________ conv2d_4 (Conv2D) (None, 8, 8, 128) 294912 _________________________________________________________________ batch_normalization_1 (Batch (None, 8, 8, 128) 512 _________________________________________________________________ leaky_re_lu_5 (LeakyReLU) (None, 8, 8, 128) 0 _________________________________________________________________ up_sampling2d_1 (UpSampling2 (None, 16, 16, 128) 0 _________________________________________________________________ conv2d_5 (Conv2D) (None, 16, 16, 64) 73728 _________________________________________________________________ batch_normalization_2 (Batch (None, 16, 16, 64) 256 _________________________________________________________________ leaky_re_lu_6 (LeakyReLU) (None, 16, 16, 64) 0 _________________________________________________________________ up_sampling2d_2 (UpSampling2 (None, 32, 32, 64) 0 _________________________________________________________________ conv2d_6 (Conv2D) (None, 32, 32, 1) 576 _________________________________________________________________ batch_normalization_3 (Batch (None, 32, 32, 1) 4 _________________________________________________________________ activation (Activation) (None, 32, 32, 1) 0 _________________________________________________________________ cropping2d (Cropping2D) (None, 28, 28, 1) 0 ================================================================= Total params: 910,660 Trainable params: 902,082 Non-trainable params: 8,578 _________________________________________________________________ Create the WGAN-GP model Now that we have defined our generator and discriminator, it's time to implement the WGAN-GP model. We will also override the train_step for training. class WGAN(keras.Model): def __init__( self, discriminator, generator, latent_dim, discriminator_extra_steps=3, gp_weight=10.0, ): super(WGAN, self).__init__() self.discriminator = discriminator self.generator = generator self.latent_dim = latent_dim self.d_steps = discriminator_extra_steps self.gp_weight = gp_weight def compile(self, d_optimizer, g_optimizer, d_loss_fn, g_loss_fn): super(WGAN, self).compile() self.d_optimizer = d_optimizer self.g_optimizer = g_optimizer self.d_loss_fn = d_loss_fn self.g_loss_fn = g_loss_fn def gradient_penalty(self, batch_size, real_images, fake_images): \"\"\" Calculates the gradient penalty. This loss is calculated on an interpolated image and added to the discriminator loss. \"\"\" # Get the interpolated image alpha = tf.random.normal([batch_size, 1, 1, 1], 0.0, 1.0) diff = fake_images - real_images interpolated = real_images + alpha * diff with tf.GradientTape() as gp_tape: gp_tape.watch(interpolated) # 1. Get the discriminator output for this interpolated image. pred = self.discriminator(interpolated, training=True) # 2. Calculate the gradients w.r.t to this interpolated image. grads = gp_tape.gradient(pred, [interpolated])[0] # 3. Calculate the norm of the gradients. norm = tf.sqrt(tf.reduce_sum(tf.square(grads), axis=[1, 2, 3])) gp = tf.reduce_mean((norm - 1.0) ** 2) return gp def train_step(self, real_images): if isinstance(real_images, tuple): real_images = real_images[0] # Get the batch size batch_size = tf.shape(real_images)[0] # For each batch, we are going to perform the # following steps as laid out in the original paper: # 1. Train the generator and get the generator loss # 2. Train the discriminator and get the discriminator loss # 3. Calculate the gradient penalty # 4. Multiply this gradient penalty with a constant weight factor # 5. Add the gradient penalty to the discriminator loss # 6. Return the generator and discriminator losses as a loss dictionary # Train the discriminator first. The original paper recommends training # the discriminator for `x` more steps (typically 5) as compared to # one step of the generator. Here we will train it for 3 extra steps # as compared to 5 to reduce the training time. for i in range(self.d_steps): # Get the latent vector random_latent_vectors = tf.random.normal( shape=(batch_size, self.latent_dim) ) with tf.GradientTape() as tape: # Generate fake images from the latent vector fake_images = self.generator(random_latent_vectors, training=True) # Get the logits for the fake images fake_logits = self.discriminator(fake_images, training=True) # Get the logits for the real images real_logits = self.discriminator(real_images, training=True) # Calculate the discriminator loss using the fake and real image logits d_cost = self.d_loss_fn(real_img=real_logits, fake_img=fake_logits) # Calculate the gradient penalty gp = self.gradient_penalty(batch_size, real_images, fake_images) # Add the gradient penalty to the original discriminator loss d_loss = d_cost + gp * self.gp_weight # Get the gradients w.r.t the discriminator loss d_gradient = tape.gradient(d_loss, self.discriminator.trainable_variables) # Update the weights of the discriminator using the discriminator optimizer self.d_optimizer.apply_gradients( zip(d_gradient, self.discriminator.trainable_variables) ) # Train the generator # Get the latent vector random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim)) with tf.GradientTape() as tape: # Generate fake images using the generator generated_images = self.generator(random_latent_vectors, training=True) # Get the discriminator logits for fake images gen_img_logits = self.discriminator(generated_images, training=True) # Calculate the generator loss g_loss = self.g_loss_fn(gen_img_logits) # Get the gradients w.r.t the generator loss gen_gradient = tape.gradient(g_loss, self.generator.trainable_variables) # Update the weights of the generator using the generator optimizer self.g_optimizer.apply_gradients( zip(gen_gradient, self.generator.trainable_variables) ) return {\"d_loss\": d_loss, \"g_loss\": g_loss} Create a Keras callback that periodically saves generated images class GANMonitor(keras.callbacks.Callback): def __init__(self, num_img=6, latent_dim=128): self.num_img = num_img self.latent_dim = latent_dim def on_epoch_end(self, epoch, logs=None): random_latent_vectors = tf.random.normal(shape=(self.num_img, self.latent_dim)) generated_images = self.model.generator(random_latent_vectors) generated_images = (generated_images * 127.5) + 127.5 for i in range(self.num_img): img = generated_images[i].numpy() img = keras.preprocessing.image.array_to_img(img) img.save(\"generated_img_{i}_{epoch}.png\".format(i=i, epoch=epoch)) Train the end-to-end model # Instantiate the optimizer for both networks # (learning_rate=0.0002, beta_1=0.5 are recommended) generator_optimizer = keras.optimizers.Adam( learning_rate=0.0002, beta_1=0.5, beta_2=0.9 ) discriminator_optimizer = keras.optimizers.Adam( learning_rate=0.0002, beta_1=0.5, beta_2=0.9 ) # Define the loss functions for the discriminator, # which should be (fake_loss - real_loss). # We will add the gradient penalty later to this loss function. def discriminator_loss(real_img, fake_img): real_loss = tf.reduce_mean(real_img) fake_loss = tf.reduce_mean(fake_img) return fake_loss - real_loss # Define the loss functions for the generator. def generator_loss(fake_img): return -tf.reduce_mean(fake_img) # Set the number of epochs for trainining. epochs = 20 # Instantiate the customer `GANMonitor` Keras callback. cbk = GANMonitor(num_img=3, latent_dim=noise_dim) # Instantiate the WGAN model. wgan = WGAN( discriminator=d_model, generator=g_model, latent_dim=noise_dim, discriminator_extra_steps=3, ) # Compile the WGAN model. wgan.compile( d_optimizer=discriminator_optimizer, g_optimizer=generator_optimizer, g_loss_fn=generator_loss, d_loss_fn=discriminator_loss, ) # Start training the model. wgan.fit(train_images, batch_size=BATCH_SIZE, epochs=epochs, callbacks=[cbk]) Epoch 1/20 118/118 [==============================] - 39s 334ms/step - d_loss: -7.6571 - g_loss: -16.9272 Epoch 2/20 118/118 [==============================] - 39s 334ms/step - d_loss: -7.2396 - g_loss: -8.5466 Epoch 3/20 118/118 [==============================] - 40s 335ms/step - d_loss: -6.3892 - g_loss: 1.3971 Epoch 4/20 118/118 [==============================] - 40s 335ms/step - d_loss: -5.7705 - g_loss: 6.5997 Epoch 5/20 118/118 [==============================] - 40s 336ms/step - d_loss: -5.2659 - g_loss: 7.4743 Epoch 6/20 118/118 [==============================] - 40s 335ms/step - d_loss: -4.9563 - g_loss: 6.2071 Epoch 7/20 118/118 [==============================] - 40s 335ms/step - d_loss: -4.5759 - g_loss: 6.4767 Epoch 8/20 118/118 [==============================] - 40s 335ms/step - d_loss: -4.3748 - g_loss: 5.4304 Epoch 9/20 118/118 [==============================] - 40s 335ms/step - d_loss: -4.1142 - g_loss: 6.4326 Epoch 10/20 118/118 [==============================] - 40s 335ms/step - d_loss: -3.7956 - g_loss: 7.1200 Epoch 11/20 118/118 [==============================] - 40s 335ms/step - d_loss: -3.5723 - g_loss: 7.1837 Epoch 12/20 118/118 [==============================] - 40s 335ms/step - d_loss: -3.4374 - g_loss: 9.0537 Epoch 13/20 118/118 [==============================] - 40s 335ms/step - d_loss: -3.3402 - g_loss: 8.4949 Epoch 14/20 118/118 [==============================] - 40s 335ms/step - d_loss: -3.1252 - g_loss: 8.6130 Epoch 15/20 118/118 [==============================] - 40s 336ms/step - d_loss: -3.0130 - g_loss: 9.4563 Epoch 16/20 118/118 [==============================] - 40s 335ms/step - d_loss: -2.9330 - g_loss: 8.8075 Epoch 17/20 118/118 [==============================] - 40s 336ms/step - d_loss: -2.7980 - g_loss: 8.0775 Epoch 18/20 118/118 [==============================] - 40s 335ms/step - d_loss: -2.7835 - g_loss: 8.7983 Epoch 19/20 118/118 [==============================] - 40s 335ms/step - d_loss: -2.6409 - g_loss: 7.8309 Epoch 20/20 118/118 [==============================] - 40s 336ms/step - d_loss: -2.5134 - g_loss: 8.6653 Display the last generated images: from IPython.display import Image, display display(Image(\"generated_img_0_19.png\")) display(Image(\"generated_img_1_19.png\")) display(Image(\"generated_img_2_19.png\")) png png png Complete implementation of WGAN-GP with R-GCN to generate novel molecules. Introduction In this tutorial, we implement a generative model for graphs and use it to generate novel molecules. Motivation: The development of new drugs (molecules) can be extremely time-consuming and costly. The use of deep learning models can alleviate the search for good candidate drugs, by predicting properties of known molecules (e.g., solubility, toxicity, affinity to target protein, etc.). As the number of possible molecules is astronomical, the space in which we search for/explore molecules is just a fraction of the entire space. Therefore, it's arguably desirable to implement generative models that can learn to generate novel molecules (which would otherwise have never been explored). References (implementation) The implementation in this tutorial is based on/inspired by the MolGAN paper and DeepChem's Basic MolGAN. Further reading (generative models) Recent implementations of generative models for molecular graphs also include Mol-CycleGAN, GraphVAE and JT-VAE. For more information on generative adverserial networks, see GAN, WGAN and WGAN-GP. Setup Install RDKit RDKit is a collection of cheminformatics and machine-learning software written in C++ and Python. In this tutorial, RDKit is used to conviently and efficiently transform SMILES to molecule objects, and then from those obtain sets of atoms and bonds. SMILES expresses the structure of a given molecule in the form of an ASCII string. The SMILES string is a compact encoding which, for smaller molecules, is relatively human-readable. Encoding molecules as a string both alleviates and facilitates database and/or web searching of a given molecule. RDKit uses algorithms to accurately transform a given SMILES to a molecule object, which can then be used to compute a great number of molecular properties/features. Notice, RDKit is commonly installed via Conda. However, thanks to rdkit_platform_wheels, rdkit can now (for the sake of this tutorial) be installed easily via pip, as follows: pip -q install rdkit-pypi And to allow easy visualization of a molecule objects, Pillow needs to be installed: pip -q install Pillow Import packages from rdkit import Chem, RDLogger from rdkit.Chem.Draw import IPythonConsole, MolsToGridImage import numpy as np import tensorflow as tf from tensorflow import keras RDLogger.DisableLog(\"rdApp.*\") Dataset The dataset used in this tutorial is a quantum mechanics dataset (QM9), obtained from MoleculeNet. Although many feature and label columns come with the dataset, we'll only focus on the SMILES column. The QM9 dataset is a good first dataset to work with for generating graphs, as the maximum number of heavy (non-hydrogen) atoms found in a molecule is only nine. csv_path = tf.keras.utils.get_file( \"qm9.csv\", \"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/qm9.csv\" ) data = [] with open(csv_path, \"r\") as f: for line in f.readlines()[1:]: data.append(line.split(\",\")[1]) # Let's look at a molecule of the dataset smiles = data[1000] print(\"SMILES:\", smiles) molecule = Chem.MolFromSmiles(smiles) print(\"Num heavy atoms:\", molecule.GetNumHeavyAtoms()) molecule SMILES: Cn1cncc1O Num heavy atoms: 7 png Define helper functions These helper functions will help convert SMILES to graphs and graphs to molecule objects. Representing a molecular graph. Molecules can naturally be expressed as undirected graphs G = (V, E), where V is a set of vertices (atoms), and E a set of edges (bonds). As for this implementation, each graph (molecule) will be represented as an adjacency tensor A, which encodes existence/non-existence of atom-pairs with their one-hot encoded bond types stretching an extra dimension, and a feature tensor H, which for each atom, one-hot encodes its atom type. Notice, as hydrogen atoms can be inferred by RDKit, hydrogen atoms are excluded from A and H for easier modeling. atom_mapping = { \"C\": 0, 0: \"C\", \"N\": 1, 1: \"N\", \"O\": 2, 2: \"O\", \"F\": 3, 3: \"F\", } bond_mapping = { \"SINGLE\": 0, 0: Chem.BondType.SINGLE, \"DOUBLE\": 1, 1: Chem.BondType.DOUBLE, \"TRIPLE\": 2, 2: Chem.BondType.TRIPLE, \"AROMATIC\": 3, 3: Chem.BondType.AROMATIC, } NUM_ATOMS = 9 # Maximum number of atoms ATOM_DIM = 4 + 1 # Number of atom types BOND_DIM = 4 + 1 # Number of bond types LATENT_DIM = 64 # Size of the latent space def smiles_to_graph(smiles): # Converts SMILES to molecule object molecule = Chem.MolFromSmiles(smiles) # Initialize adjacency and feature tensor adjacency = np.zeros((BOND_DIM, NUM_ATOMS, NUM_ATOMS), \"float32\") features = np.zeros((NUM_ATOMS, ATOM_DIM), \"float32\") # loop over each atom in molecule for atom in molecule.GetAtoms(): i = atom.GetIdx() atom_type = atom_mapping[atom.GetSymbol()] features[i] = np.eye(ATOM_DIM)[atom_type] # loop over one-hop neighbors for neighbor in atom.GetNeighbors(): j = neighbor.GetIdx() bond = molecule.GetBondBetweenAtoms(i, j) bond_type_idx = bond_mapping[bond.GetBondType().name] adjacency[bond_type_idx, [i, j], [j, i]] = 1 # Where no bond, add 1 to last channel (indicating \"non-bond\") # Notice: channels-first adjacency[-1, np.sum(adjacency, axis=0) == 0] = 1 # Where no atom, add 1 to last column (indicating \"non-atom\") features[np.where(np.sum(features, axis=1) == 0)[0], -1] = 1 return adjacency, features def graph_to_molecule(graph): # Unpack graph adjacency, features = graph # RWMol is a molecule object intended to be edited molecule = Chem.RWMol() # Remove \"no atoms\" & atoms with no bonds keep_idx = np.where( (np.argmax(features, axis=1) != ATOM_DIM - 1) & (np.sum(adjacency[:-1], axis=(0, 1)) != 0) )[0] features = features[keep_idx] adjacency = adjacency[:, keep_idx, :][:, :, keep_idx] # Add atoms to molecule for atom_type_idx in np.argmax(features, axis=1): atom = Chem.Atom(atom_mapping[atom_type_idx]) _ = molecule.AddAtom(atom) # Add bonds between atoms in molecule; based on the upper triangles # of the [symmetric] adjacency tensor (bonds_ij, atoms_i, atoms_j) = np.where(np.triu(adjacency) == 1) for (bond_ij, atom_i, atom_j) in zip(bonds_ij, atoms_i, atoms_j): if atom_i == atom_j or bond_ij == BOND_DIM - 1: continue bond_type = bond_mapping[bond_ij] molecule.AddBond(int(atom_i), int(atom_j), bond_type) # Sanitize the molecule; for more information on sanitization, see # https://www.rdkit.org/docs/RDKit_Book.html#molecular-sanitization flag = Chem.SanitizeMol(molecule, catchErrors=True) # Let's be strict. If sanitization fails, return None if flag != Chem.SanitizeFlags.SANITIZE_NONE: return None return molecule # Test helper functions graph_to_molecule(smiles_to_graph(smiles)) png Generate training set To save training time, we'll only use a tenth of the QM9 dataset. adjacency_tensor, feature_tensor = [], [] for smiles in data[::10]: adjacency, features = smiles_to_graph(smiles) adjacency_tensor.append(adjacency) feature_tensor.append(features) adjacency_tensor = np.array(adjacency_tensor) feature_tensor = np.array(feature_tensor) print(\"adjacency_tensor.shape =\", adjacency_tensor.shape) print(\"feature_tensor.shape =\", feature_tensor.shape) adjacency_tensor.shape = (13389, 5, 9, 9) feature_tensor.shape = (13389, 9, 5) Model The idea is to implement a generator network and a discriminator network via WGAN-GP, that will result in a generator network that can generate small novel molecules (small graphs). The generator network needs to be able to map (for each example in the batch) a vector z to a 3-D adjacency tensor (A) and 2-D feature tensor (H). For this, z will first be passed through a fully-connected network, for which the output will be further passed through two separate fully-connected networks. Each of these two fully-connected networks will then output (for each example in the batch) a tanh-activated vector followed by a reshape and softmax to match that of a multi-dimensional adjacency/feature tensor. As the discriminator network will recieves as input a graph (A, H) from either the genrator or from the training set, we'll need to implement graph convolutional layers, which allows us to operate on graphs. This means that input to the discriminator network will first pass through graph convolutional layers, then an average-pooling layer, and finally a few fully-connected layers. The final output should be a scalar (for each example in the batch) which indicates the \"realness\" of the associated input (in this case a \"fake\" or \"real\" molecule). Graph generator def GraphGenerator( dense_units, dropout_rate, latent_dim, adjacency_shape, feature_shape, ): z = keras.layers.Input(shape=(LATENT_DIM,)) # Propagate through one or more densely connected layers x = z for units in dense_units: x = keras.layers.Dense(units, activation=\"tanh\")(x) x = keras.layers.Dropout(dropout_rate)(x) # Map outputs of previous layer (x) to [continuous] adjacency tensors (x_adjacency) x_adjacency = keras.layers.Dense(tf.math.reduce_prod(adjacency_shape))(x) x_adjacency = keras.layers.Reshape(adjacency_shape)(x_adjacency) # Symmetrify tensors in the last two dimensions x_adjacency = (x_adjacency + tf.transpose(x_adjacency, (0, 1, 3, 2))) / 2 x_adjacency = keras.layers.Softmax(axis=1)(x_adjacency) # Map outputs of previous layer (x) to [continuous] feature tensors (x_features) x_features = keras.layers.Dense(tf.math.reduce_prod(feature_shape))(x) x_features = keras.layers.Reshape(feature_shape)(x_features) x_features = keras.layers.Softmax(axis=2)(x_features) return keras.Model(inputs=z, outputs=[x_adjacency, x_features], name=\"Generator\") generator = GraphGenerator( dense_units=[128, 256, 512], dropout_rate=0.2, latent_dim=LATENT_DIM, adjacency_shape=(BOND_DIM, NUM_ATOMS, NUM_ATOMS), feature_shape=(NUM_ATOMS, ATOM_DIM), ) generator.summary() Model: \"Generator\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 64)] 0 __________________________________________________________________________________________________ dense (Dense) (None, 128) 8320 input_1[0][0] __________________________________________________________________________________________________ dropout (Dropout) (None, 128) 0 dense[0][0] __________________________________________________________________________________________________ dense_1 (Dense) (None, 256) 33024 dropout[0][0] __________________________________________________________________________________________________ dropout_1 (Dropout) (None, 256) 0 dense_1[0][0] __________________________________________________________________________________________________ dense_2 (Dense) (None, 512) 131584 dropout_1[0][0] __________________________________________________________________________________________________ dropout_2 (Dropout) (None, 512) 0 dense_2[0][0] __________________________________________________________________________________________________ dense_3 (Dense) (None, 405) 207765 dropout_2[0][0] __________________________________________________________________________________________________ reshape (Reshape) (None, 5, 9, 9) 0 dense_3[0][0] __________________________________________________________________________________________________ tf.compat.v1.transpose (TFOpLam (None, 5, 9, 9) 0 reshape[0][0] __________________________________________________________________________________________________ tf.__operators__.add (TFOpLambd (None, 5, 9, 9) 0 reshape[0][0] tf.compat.v1.transpose[0][0] __________________________________________________________________________________________________ dense_4 (Dense) (None, 45) 23085 dropout_2[0][0] __________________________________________________________________________________________________ tf.math.truediv (TFOpLambda) (None, 5, 9, 9) 0 tf.__operators__.add[0][0] __________________________________________________________________________________________________ reshape_1 (Reshape) (None, 9, 5) 0 dense_4[0][0] __________________________________________________________________________________________________ softmax (Softmax) (None, 5, 9, 9) 0 tf.math.truediv[0][0] __________________________________________________________________________________________________ softmax_1 (Softmax) (None, 9, 5) 0 reshape_1[0][0] ================================================================================================== Total params: 403,778 Trainable params: 403,778 Non-trainable params: 0 __________________________________________________________________________________________________ Graph discriminator Graph convolutional layer. The relational graph convolutional layers implements non-linearly transformed neighborhood aggregations. We can define these layers as follows: H^{l+1} = σ(D^{-1} @ A @ H^{l+1} @ W^{l}) Where σ denotes the non-linear transformation (commonly a ReLU activation), A the adjacency tensor, H^{l} the feature tensor at the l:th layer, D^{-1} the inverse diagonal degree tensor of A, and W^{l} the trainable weight tensor at the l:th layer. Specifically, for each bond type (relation), the degree tensor expresses, in the diagonal, the number of bonds attached to each atom. Notice, in this tutorial D^{-1} is omitted, for two reasons: (1) it's not obvious how to apply this normalization on the continuous adjacency tensors (generated by the generator), and (2) the performance of the WGAN without normalization seems to work just fine. Furthermore, in contrast to the original paper, no self-loop is defined, as we don't want to train the generator to predict \"self-bonding\". class RelationalGraphConvLayer(keras.layers.Layer): def __init__( self, units=128, activation=\"relu\", use_bias=False, kernel_initializer=\"glorot_uniform\", bias_initializer=\"zeros\", kernel_regularizer=None, bias_regularizer=None, **kwargs ): super().__init__(**kwargs) self.units = units self.activation = keras.activations.get(activation) self.use_bias = use_bias self.kernel_initializer = keras.initializers.get(kernel_initializer) self.bias_initializer = keras.initializers.get(bias_initializer) self.kernel_regularizer = keras.regularizers.get(kernel_regularizer) self.bias_regularizer = keras.regularizers.get(bias_regularizer) def build(self, input_shape): bond_dim = input_shape[0][1] atom_dim = input_shape[1][2] self.kernel = self.add_weight( shape=(bond_dim, atom_dim, self.units), initializer=self.kernel_initializer, regularizer=self.kernel_regularizer, trainable=True, name=\"W\", dtype=tf.float32, ) if self.use_bias: self.bias = self.add_weight( shape=(bond_dim, 1, self.units), initializer=self.bias_initializer, regularizer=self.bias_regularizer, trainable=True, name=\"b\", dtype=tf.float32, ) self.built = True def call(self, inputs, training=False): adjacency, features = inputs # Aggregate information from neighbors x = tf.matmul(adjacency, features[:, None, :, :]) # Apply linear transformation x = tf.matmul(x, self.kernel) if self.use_bias: x += self.bias # Reduce bond types dim x_reduced = tf.reduce_sum(x, axis=1) # Apply non-linear transformation return self.activation(x_reduced) def GraphDiscriminator( gconv_units, dense_units, dropout_rate, adjacency_shape, feature_shape ): adjacency = keras.layers.Input(shape=adjacency_shape) features = keras.layers.Input(shape=feature_shape) # Propagate through one or more graph convolutional layers features_transformed = features for units in gconv_units: features_transformed = RelationalGraphConvLayer(units)( [adjacency, features_transformed] ) # Reduce 2-D representation of molecule to 1-D x = keras.layers.GlobalAveragePooling1D()(features_transformed) # Propagate through one or more densely connected layers for units in dense_units: x = keras.layers.Dense(units, activation=\"relu\")(x) x = keras.layers.Dropout(dropout_rate)(x) # For each molecule, output a single scalar value expressing the # \"realness\" of the inputted molecule x_out = keras.layers.Dense(1, dtype=\"float32\")(x) return keras.Model(inputs=[adjacency, features], outputs=x_out) discriminator = GraphDiscriminator( gconv_units=[128, 128, 128, 128], dense_units=[512, 512], dropout_rate=0.2, adjacency_shape=(BOND_DIM, NUM_ATOMS, NUM_ATOMS), feature_shape=(NUM_ATOMS, ATOM_DIM), ) discriminator.summary() Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_2 (InputLayer) [(None, 5, 9, 9)] 0 __________________________________________________________________________________________________ input_3 (InputLayer) [(None, 9, 5)] 0 __________________________________________________________________________________________________ relational_graph_conv_layer (Re (None, 9, 128) 3200 input_2[0][0] input_3[0][0] __________________________________________________________________________________________________ relational_graph_conv_layer_1 ( (None, 9, 128) 81920 input_2[0][0] relational_graph_conv_layer[0][0] __________________________________________________________________________________________________ relational_graph_conv_layer_2 ( (None, 9, 128) 81920 input_2[0][0] relational_graph_conv_layer_1[0][ __________________________________________________________________________________________________ relational_graph_conv_layer_3 ( (None, 9, 128) 81920 input_2[0][0] relational_graph_conv_layer_2[0][ __________________________________________________________________________________________________ global_average_pooling1d (Globa (None, 128) 0 relational_graph_conv_layer_3[0][ __________________________________________________________________________________________________ dense_5 (Dense) (None, 512) 66048 global_average_pooling1d[0][0] __________________________________________________________________________________________________ dropout_3 (Dropout) (None, 512) 0 dense_5[0][0] __________________________________________________________________________________________________ dense_6 (Dense) (None, 512) 262656 dropout_3[0][0] __________________________________________________________________________________________________ dropout_4 (Dropout) (None, 512) 0 dense_6[0][0] __________________________________________________________________________________________________ dense_7 (Dense) (None, 1) 513 dropout_4[0][0] ================================================================================================== Total params: 578,177 Trainable params: 578,177 Non-trainable params: 0 __________________________________________________________________________________________________ WGAN-GP class GraphWGAN(keras.Model): def __init__( self, generator, discriminator, discriminator_steps=1, generator_steps=1, gp_weight=10, **kwargs ): super().__init__(**kwargs) self.generator = generator self.discriminator = discriminator self.discriminator_steps = discriminator_steps self.generator_steps = generator_steps self.gp_weight = gp_weight self.latent_dim = self.generator.input_shape[-1] def compile(self, optimizer_generator, optimizer_discriminator, **kwargs): super().compile(**kwargs) self.optimizer_generator = optimizer_generator self.optimizer_discriminator = optimizer_discriminator self.metric_generator = keras.metrics.Mean(name=\"loss_gen\") self.metric_discriminator = keras.metrics.Mean(name=\"loss_dis\") def train_step(self, inputs): if isinstance(inputs[0], tuple): inputs = inputs[0] graph_real = inputs self.batch_size = tf.shape(inputs[0])[0] # Train the discriminator for one or more steps for _ in range(self.discriminator_steps): z = tf.random.normal((self.batch_size, self.latent_dim)) with tf.GradientTape() as tape: graph_generated = self.generator(z, training=True) loss = self._loss_discriminator(graph_real, graph_generated) grads = tape.gradient(loss, self.discriminator.trainable_weights) self.optimizer_discriminator.apply_gradients( zip(grads, self.discriminator.trainable_weights) ) self.metric_discriminator.update_state(loss) # Train the generator for one or more steps for _ in range(self.generator_steps): z = tf.random.normal((self.batch_size, self.latent_dim)) with tf.GradientTape() as tape: graph_generated = self.generator(z, training=True) loss = self._loss_generator(graph_generated) grads = tape.gradient(loss, self.generator.trainable_weights) self.optimizer_generator.apply_gradients( zip(grads, self.generator.trainable_weights) ) self.metric_generator.update_state(loss) return {m.name: m.result() for m in self.metrics} def _loss_discriminator(self, graph_real, graph_generated): logits_real = self.discriminator(graph_real, training=True) logits_generated = self.discriminator(graph_generated, training=True) loss = tf.reduce_mean(logits_generated) - tf.reduce_mean(logits_real) loss_gp = self._gradient_penalty(graph_real, graph_generated) return loss + loss_gp * self.gp_weight def _loss_generator(self, graph_generated): logits_generated = self.discriminator(graph_generated, training=True) return -tf.reduce_mean(logits_generated) def _gradient_penalty(self, graph_real, graph_generated): # Unpack graphs adjacency_real, features_real = graph_real adjacency_generated, features_generated = graph_generated # Generate interpolated graphs (adjacency_interp and features_interp) alpha = tf.random.uniform([self.batch_size]) alpha = tf.reshape(alpha, (self.batch_size, 1, 1, 1)) adjacency_interp = (adjacency_real * alpha) + (1 - alpha) * adjacency_generated alpha = tf.reshape(alpha, (self.batch_size, 1, 1)) features_interp = (features_real * alpha) + (1 - alpha) * features_generated # Compute the logits of interpolated graphs with tf.GradientTape() as tape: tape.watch(adjacency_interp) tape.watch(features_interp) logits = self.discriminator( [adjacency_interp, features_interp], training=True ) # Compute the gradients with respect to the interpolated graphs grads = tape.gradient(logits, [adjacency_interp, features_interp]) # Compute the gradient penalty grads_adjacency_penalty = (1 - tf.norm(grads[0], axis=1)) ** 2 grads_features_penalty = (1 - tf.norm(grads[1], axis=2)) ** 2 return tf.reduce_mean( tf.reduce_mean(grads_adjacency_penalty, axis=(-2, -1)) + tf.reduce_mean(grads_features_penalty, axis=(-1)) ) Train the model To save time (if run on a CPU), we'll only train the model for 10 epochs. wgan = GraphWGAN(generator, discriminator, discriminator_steps=1) wgan.compile( optimizer_generator=keras.optimizers.Adam(5e-4), optimizer_discriminator=keras.optimizers.Adam(5e-4), ) wgan.fit([adjacency_tensor, feature_tensor], epochs=10, batch_size=16) Epoch 1/10 837/837 [==============================] - 27s 29ms/step - loss_gen: 1.2595 - loss_dis: -3.7314 Epoch 2/10 837/837 [==============================] - 24s 29ms/step - loss_gen: 0.2039 - loss_dis: -1.4319 Epoch 3/10 837/837 [==============================] - 25s 29ms/step - loss_gen: 0.2395 - loss_dis: -1.4390 Epoch 4/10 837/837 [==============================] - 26s 31ms/step - loss_gen: -0.0859 - loss_dis: -1.2093 Epoch 5/10 837/837 [==============================] - 25s 29ms/step - loss_gen: 0.3703 - loss_dis: -1.4996 Epoch 6/10 837/837 [==============================] - 24s 29ms/step - loss_gen: 0.9488 - loss_dis: -1.9018 Epoch 7/10 837/837 [==============================] - 24s 29ms/step - loss_gen: 0.8143 - loss_dis: -2.0511 Epoch 8/10 837/837 [==============================] - 25s 30ms/step - loss_gen: 0.9974 - loss_dis: -2.0642 Epoch 9/10 837/837 [==============================] - 24s 29ms/step - loss_gen: 1.2580 - loss_dis: -2.3094 Epoch 10/10 837/837 [==============================] - 24s 29ms/step - loss_gen: 1.6188 - loss_dis: -2.5193 Sample novel molecules with the generator def sample(generator, batch_size): z = tf.random.normal((batch_size, LATENT_DIM)) graph = generator.predict(z) # obtain one-hot encoded adjacency tensor adjacency = tf.argmax(graph[0], axis=1) adjacency = tf.one_hot(adjacency, depth=BOND_DIM, axis=1) # Remove potential self-loops from adjacency adjacency = tf.linalg.set_diag(adjacency, tf.zeros(tf.shape(adjacency)[:-1])) # obtain one-hot encoded feature tensor features = tf.argmax(graph[1], axis=2) features = tf.one_hot(features, depth=ATOM_DIM, axis=2) return [ graph_to_molecule([adjacency[i].numpy(), features[i].numpy()]) for i in range(batch_size) ] molecules = sample(wgan.generator, batch_size=48) MolsToGridImage( [m for m in molecules if m is not None][:25], molsPerRow=5, subImgSize=(150, 150) ) png Concluding thoughts Inspecting the results. Ten epochs of training seemed enough to generate some decent looking molecules! Notice, in contrast to the MolGAN paper, the uniqueness of the generated molecules in this tutorial seems really high, which is great! What we've learned, and prospects. In this tutorial, a generative model for molecular graphs was succesfully implemented, which allowed us to generate novel molecules. In the future, it would be interesting to implement generative models that can modify existing molecules (for instance, to optimize solubility or protein-binding of an existing molecule). For that however, a reconstruction loss would likely be needed, which is tricky to implement as there's no easy and obvious way to compute similarity between two molecular graphs. An implementation of Graph Attention Networks (GATs) for node classification. Introduction This code example solves the CartPole-v0 environment using a Proximal Policy Optimization (PPO) agent. CartPole-v0 A pole is attached by an un-actuated joint to a cart, which moves along a frictionless track. The system is controlled by applying a force of +1 or -1 to the cart. The pendulum starts upright, and the goal is to prevent it from falling over. A reward of +1 is provided for every timestep that the pole remains upright. The episode ends when the pole is more than 15 degrees from vertical, or the cart moves more than 2.4 units from the center. After 200 steps the episode ends. Thus, the highest return we can get is equal to 200. CartPole-v0 Proximal Policy Optimization PPO is a policy gradient method and can be used for environments with either discrete or continuous action spaces. It trains a stochastic policy in an on-policy way. Also, it utilizes the actor critic method. The actor maps the observation to an action and the critic gives an expectation of the rewards of the agent for the observation given. Firstly, it collects a set of trajectories for each epoch by sampling from the latest version of the stochastic policy. Then, the rewards-to-go and the advantage estimates are computed in order to update the policy and fit the value function. The policy is updated via a stochastic gradient ascent optimizer, while the value function is fitted via some gradient descent algorithm. This procedure is applied for many epochs until the environment is solved. Algorithm PPO Original Paper OpenAI Spinning Up docs - PPO Note This code example uses Keras and Tensorflow v2. It is based on the PPO Original Paper, the OpenAI's Spinning Up docs for PPO, and the OpenAI's Spinning Up implementation of PPO using Tensorflow v1. OpenAI Spinning Up Github - PPO Libraries For this example the following libraries are used: numpy for n-dimensional arrays tensorflow and keras for building the deep RL PPO agent gym for getting everything we need about the environment scipy.signal for calculating the discounted cumulative sums of vectors import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import gym import scipy.signal import time Functions and class def discounted_cumulative_sums(x, discount): # Discounted cumulative sums of vectors for computing rewards-to-go and advantage estimates return scipy.signal.lfilter([1], [1, float(-discount)], x[::-1], axis=0)[::-1] class Buffer: # Buffer for storing trajectories def __init__(self, observation_dimensions, size, gamma=0.99, lam=0.95): # Buffer initialization self.observation_buffer = np.zeros( (size, observation_dimensions), dtype=np.float32 ) self.action_buffer = np.zeros(size, dtype=np.int32) self.advantage_buffer = np.zeros(size, dtype=np.float32) self.reward_buffer = np.zeros(size, dtype=np.float32) self.return_buffer = np.zeros(size, dtype=np.float32) self.value_buffer = np.zeros(size, dtype=np.float32) self.logprobability_buffer = np.zeros(size, dtype=np.float32) self.gamma, self.lam = gamma, lam self.pointer, self.trajectory_start_index = 0, 0 def store(self, observation, action, reward, value, logprobability): # Append one step of agent-environment interaction self.observation_buffer[self.pointer] = observation self.action_buffer[self.pointer] = action self.reward_buffer[self.pointer] = reward self.value_buffer[self.pointer] = value self.logprobability_buffer[self.pointer] = logprobability self.pointer += 1 def finish_trajectory(self, last_value=0): # Finish the trajectory by computing advantage estimates and rewards-to-go path_slice = slice(self.trajectory_start_index, self.pointer) rewards = np.append(self.reward_buffer[path_slice], last_value) values = np.append(self.value_buffer[path_slice], last_value) deltas = rewards[:-1] + self.gamma * values[1:] - values[:-1] self.advantage_buffer[path_slice] = discounted_cumulative_sums( deltas, self.gamma * self.lam ) self.return_buffer[path_slice] = discounted_cumulative_sums( rewards, self.gamma )[:-1] self.trajectory_start_index = self.pointer def get(self): # Get all data of the buffer and normalize the advantages self.pointer, self.trajectory_start_index = 0, 0 advantage_mean, advantage_std = ( np.mean(self.advantage_buffer), np.std(self.advantage_buffer), ) self.advantage_buffer = (self.advantage_buffer - advantage_mean) / advantage_std return ( self.observation_buffer, self.action_buffer, self.advantage_buffer, self.return_buffer, self.logprobability_buffer, ) def mlp(x, sizes, activation=tf.tanh, output_activation=None): # Build a feedforward neural network for size in sizes[:-1]: x = layers.Dense(units=size, activation=activation)(x) return layers.Dense(units=sizes[-1], activation=output_activation)(x) def logprobabilities(logits, a): # Compute the log-probabilities of taking actions a by using the logits (i.e. the output of the actor) logprobabilities_all = tf.nn.log_softmax(logits) logprobability = tf.reduce_sum( tf.one_hot(a, num_actions) * logprobabilities_all, axis=1 ) return logprobability # Sample action from actor @tf.function def sample_action(observation): logits = actor(observation) action = tf.squeeze(tf.random.categorical(logits, 1), axis=1) return logits, action # Train the policy by maxizing the PPO-Clip objective @tf.function def train_policy( observation_buffer, action_buffer, logprobability_buffer, advantage_buffer ): with tf.GradientTape() as tape: # Record operations for automatic differentiation. ratio = tf.exp( logprobabilities(actor(observation_buffer), action_buffer) - logprobability_buffer ) min_advantage = tf.where( advantage_buffer > 0, (1 + clip_ratio) * advantage_buffer, (1 - clip_ratio) * advantage_buffer, ) policy_loss = -tf.reduce_mean( tf.minimum(ratio * advantage_buffer, min_advantage) ) policy_grads = tape.gradient(policy_loss, actor.trainable_variables) policy_optimizer.apply_gradients(zip(policy_grads, actor.trainable_variables)) kl = tf.reduce_mean( logprobability_buffer - logprobabilities(actor(observation_buffer), action_buffer) ) kl = tf.reduce_sum(kl) return kl # Train the value function by regression on mean-squared error @tf.function def train_value_function(observation_buffer, return_buffer): with tf.GradientTape() as tape: # Record operations for automatic differentiation. value_loss = tf.reduce_mean((return_buffer - critic(observation_buffer)) ** 2) value_grads = tape.gradient(value_loss, critic.trainable_variables) value_optimizer.apply_gradients(zip(value_grads, critic.trainable_variables)) Hyperparameters # Hyperparameters of the PPO algorithm steps_per_epoch = 4000 epochs = 30 gamma = 0.99 clip_ratio = 0.2 policy_learning_rate = 3e-4 value_function_learning_rate = 1e-3 train_policy_iterations = 80 train_value_iterations = 80 lam = 0.97 target_kl = 0.01 hidden_sizes = (64, 64) # True if you want to render the environment render = False Initializations # Initialize the environment and get the dimensionality of the # observation space and the number of possible actions env = gym.make(\"CartPole-v0\") observation_dimensions = env.observation_space.shape[0] num_actions = env.action_space.n # Initialize the buffer buffer = Buffer(observation_dimensions, steps_per_epoch) # Initialize the actor and the critic as keras models observation_input = keras.Input(shape=(observation_dimensions,), dtype=tf.float32) logits = mlp(observation_input, list(hidden_sizes) + [num_actions], tf.tanh, None) actor = keras.Model(inputs=observation_input, outputs=logits) value = tf.squeeze( mlp(observation_input, list(hidden_sizes) + [1], tf.tanh, None), axis=1 ) critic = keras.Model(inputs=observation_input, outputs=value) # Initialize the policy and the value function optimizers policy_optimizer = keras.optimizers.Adam(learning_rate=policy_learning_rate) value_optimizer = keras.optimizers.Adam(learning_rate=value_function_learning_rate) # Initialize the observation, episode return and episode length observation, episode_return, episode_length = env.reset(), 0, 0 Train # Iterate over the number of epochs for epoch in range(epochs): # Initialize the sum of the returns, lengths and number of episodes for each epoch sum_return = 0 sum_length = 0 num_episodes = 0 # Iterate over the steps of each epoch for t in range(steps_per_epoch): if render: env.render() # Get the logits, action, and take one step in the environment observation = observation.reshape(1, -1) logits, action = sample_action(observation) observation_new, reward, done, _ = env.step(action[0].numpy()) episode_return += reward episode_length += 1 # Get the value and log-probability of the action value_t = critic(observation) logprobability_t = logprobabilities(logits, action) # Store obs, act, rew, v_t, logp_pi_t buffer.store(observation, action, reward, value_t, logprobability_t) # Update the observation observation = observation_new # Finish trajectory if reached to a terminal state terminal = done if terminal or (t == steps_per_epoch - 1): last_value = 0 if done else critic(observation.reshape(1, -1)) buffer.finish_trajectory(last_value) sum_return += episode_return sum_length += episode_length num_episodes += 1 observation, episode_return, episode_length = env.reset(), 0, 0 # Get values from the buffer ( observation_buffer, action_buffer, advantage_buffer, return_buffer, logprobability_buffer, ) = buffer.get() # Update the policy and implement early stopping using KL divergence for _ in range(train_policy_iterations): kl = train_policy( observation_buffer, action_buffer, logprobability_buffer, advantage_buffer ) if kl > 1.5 * target_kl: # Early Stopping break # Update the value function for _ in range(train_value_iterations): train_value_function(observation_buffer, return_buffer) # Print mean return and length for each epoch print( f\" Epoch: {epoch + 1}. Mean Return: {sum_return / num_episodes}. Mean Length: {sum_length / num_episodes}\" ) Epoch: 1. Mean Return: 18.01801801801802. Mean Length: 18.01801801801802 Epoch: 2. Mean Return: 21.978021978021978. Mean Length: 21.978021978021978 Epoch: 3. Mean Return: 27.397260273972602. Mean Length: 27.397260273972602 Epoch: 4. Mean Return: 36.69724770642202. Mean Length: 36.69724770642202 Epoch: 5. Mean Return: 48.19277108433735. Mean Length: 48.19277108433735 Epoch: 6. Mean Return: 66.66666666666667. Mean Length: 66.66666666666667 Epoch: 7. Mean Return: 133.33333333333334. Mean Length: 133.33333333333334 Epoch: 8. Mean Return: 166.66666666666666. Mean Length: 166.66666666666666 Epoch: 9. Mean Return: 181.8181818181818. Mean Length: 181.8181818181818 Epoch: 10. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 11. Mean Return: 200.0. Mean Length: 200.0 Epoch: 12. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 13. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 14. Mean Return: 181.8181818181818. Mean Length: 181.8181818181818 Epoch: 15. Mean Return: 181.8181818181818. Mean Length: 181.8181818181818 Epoch: 16. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 17. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 18. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 19. Mean Return: 200.0. Mean Length: 200.0 Epoch: 20. Mean Return: 200.0. Mean Length: 200.0 Epoch: 21. Mean Return: 200.0. Mean Length: 200.0 Epoch: 22. Mean Return: 200.0. Mean Length: 200.0 Epoch: 23. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 24. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 25. Mean Return: 200.0. Mean Length: 200.0 Epoch: 26. Mean Return: 200.0. Mean Length: 200.0 Epoch: 27. Mean Return: 200.0. Mean Length: 200.0 Epoch: 28. Mean Return: 200.0. Mean Length: 200.0 Epoch: 29. Mean Return: 200.0. Mean Length: 200.0 Epoch: 30. Mean Return: 200.0. Mean Length: 200.0 Visualizations Before training: Imgur After 8 epochs of training: Imgur After 20 epochs of training: Imgur Implementing the node2vec model to generate embeddings for movies from the MovieLens dataset. Introduction Learning useful representations from objects structured as graphs is useful for a variety of machine learning (ML) applications—such as social and communication networks analysis, biomedicine studies, and recommendation systems. Graph representation Learning aims to learn embeddings for the graph nodes, which can be used for a variety of ML tasks such as node label prediction (e.g. categorizing an article based on its citations) and link prediction (e.g. recommending an interest group to a user in a social network). node2vec is a simple, yet scalable and effective technique for learning low-dimensional embeddings for nodes in a graph by optimizing a neighborhood-preserving objective. The aim is to learn similar embeddings for neighboring nodes, with respect to the graph structure. Given your data items structured as a graph (where the items are represented as nodes and the relationship between items are represented as edges), node2vec works as follows: Generate item sequences using (biased) random walk. Create positive and negative training examples from these sequences. Train a word2vec model (skip-gram) to learn embeddings for the items. In this example, we demonstrate the node2vec technique on the small version of the Movielens dataset to learn movie embeddings. Such a dataset can be represented as a graph by treating the movies as nodes, and creating edges between movies that have similar ratings by the users. The learnt movie embeddings can be used for tasks such as movie recommendation, or movie genres prediction. This example requires networkx package, which can be installed using the following command: pip install networkx Setup import os from collections import defaultdict import math import networkx as nx import random from tqdm import tqdm from zipfile import ZipFile from urllib.request import urlretrieve import numpy as np import pandas as pd import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import matplotlib.pyplot as plt Download the MovieLens dataset and prepare the data The small version of the MovieLens dataset includes around 100k ratings from 610 users on 9,742 movies. First, let's download the dataset. The downloaded folder will contain three data files: users.csv, movies.csv, and ratings.csv. In this example, we will only need the movies.dat, and ratings.dat data files. urlretrieve( \"http://files.grouplens.org/datasets/movielens/ml-latest-small.zip\", \"movielens.zip\" ) ZipFile(\"movielens.zip\", \"r\").extractall() Then, we load the data into a Pandas DataFrame and perform some basic preprocessing. # Load movies to a DataFrame. movies = pd.read_csv(\"ml-latest-small/movies.csv\") # Create a `movieId` string. movies[\"movieId\"] = movies[\"movieId\"].apply(lambda x: f\"movie_{x}\") # Load ratings to a DataFrame. ratings = pd.read_csv(\"ml-latest-small/ratings.csv\") # Convert the `ratings` to floating point ratings[\"rating\"] = ratings[\"rating\"].apply(lambda x: float(x)) # Create the `movie_id` string. ratings[\"movieId\"] = ratings[\"movieId\"].apply(lambda x: f\"movie_{x}\") print(\"Movies data shape:\", movies.shape) print(\"Ratings data shape:\", ratings.shape) Movies data shape: (9742, 3) Ratings data shape: (100836, 4) Let's inspect a sample instance of the ratings DataFrame. ratings.head() userId movieId rating timestamp 0 1 movie_1 4.0 964982703 1 1 movie_3 4.0 964981247 2 1 movie_6 4.0 964982224 3 1 movie_47 5.0 964983815 4 1 movie_50 5.0 964982931 Next, let's check a sample instance of the movies DataFrame. movies.head() movieId title genres 0 movie_1 Toy Story (1995) Adventure|Animation|Children|Comedy|Fantasy 1 movie_2 Jumanji (1995) Adventure|Children|Fantasy 2 movie_3 Grumpier Old Men (1995) Comedy|Romance 3 movie_4 Waiting to Exhale (1995) Comedy|Drama|Romance 4 movie_5 Father of the Bride Part II (1995) Comedy Implement two utility functions for the movies DataFrame. def get_movie_title_by_id(movieId): return list(movies[movies.movieId == movieId].title)[0] def get_movie_id_by_title(title): return list(movies[movies.title == title].movieId)[0] Construct the Movies graph We create an edge between two movie nodes in the graph if both movies are rated by the same user >= min_rating. The weight of the edge will be based on the pointwise mutual information between the two movies, which is computed as: log(xy) - log(x) - log(y) + log(D), where: xy is how many users rated both movie x and movie y with >= min_rating. x is how many users rated movie x >= min_rating. y is how many users rated movie y >= min_rating. D total number of movie ratings >= min_rating. Step 1: create the weighted edges between movies. min_rating = 5 pair_frequency = defaultdict(int) item_frequency = defaultdict(int) # Filter instances where rating is greater than or equal to min_rating. rated_movies = ratings[ratings.rating >= min_rating] # Group instances by user. movies_grouped_by_users = list(rated_movies.groupby(\"userId\")) for group in tqdm( movies_grouped_by_users, position=0, leave=True, desc=\"Compute movie rating frequencies\", ): # Get a list of movies rated by the user. current_movies = list(group[1][\"movieId\"]) for i in range(len(current_movies)): item_frequency[current_movies[i]] += 1 for j in range(i + 1, len(current_movies)): x = min(current_movies[i], current_movies[j]) y = max(current_movies[i], current_movies[j]) pair_frequency[(x, y)] += 1 Compute movie rating frequencies: 100%|██████████| 573/573 [00:00<00:00, 1041.36it/s] Step 2: create the graph with the nodes and the edges To reduce the number of edges between nodes, we only add an edge between movies if the weight of the edge is greater than min_weight. min_weight = 10 D = math.log(sum(item_frequency.values())) # Create the movies undirected graph. movies_graph = nx.Graph() # Add weighted edges between movies. # This automatically adds the movie nodes to the graph. for pair in tqdm( pair_frequency, position=0, leave=True, desc=\"Creating the movie graph\" ): x, y = pair xy_frequency = pair_frequency[pair] x_frequency = item_frequency[x] y_frequency = item_frequency[y] pmi = math.log(xy_frequency) - math.log(x_frequency) - math.log(y_frequency) + D weight = pmi * xy_frequency # Only include edges with weight >= min_weight. if weight >= min_weight: movies_graph.add_edge(x, y, weight=weight) Creating the movie graph: 100%|██████████| 298586/298586 [00:00<00:00, 762305.97it/s] Let's display the total number of nodes and edges in the graph. Note that the number of nodes is less than the total number of movies, since only the movies that have edges to other movies are added. print(\"Total number of graph nodes:\", movies_graph.number_of_nodes()) print(\"Total number of graph edges:\", movies_graph.number_of_edges()) Total number of graph nodes: 1405 Total number of graph edges: 40043 Let's display the average node degree (number of neighbours) in the graph. degrees = [] for node in movies_graph.nodes: degrees.append(movies_graph.degree[node]) print(\"Average node degree:\", round(sum(degrees) / len(degrees), 2)) Average node degree: 57.0 Step 3: Create vocabulary and a mapping from tokens to integer indices The vocabulary is the nodes (movie IDs) in the graph. vocabulary = [\"NA\"] + list(movies_graph.nodes) vocabulary_lookup = {token: idx for idx, token in enumerate(vocabulary)} Implement the biased random walk A random walk starts from a given node, and randomly picks a neighbour node to move to. If the edges are weighted, the neighbour is selected probabilistically with respect to weights of the edges between the current node and its neighbours. This procedure is repeated for num_steps to generate a sequence of related nodes. The biased random walk balances between breadth-first sampling (where only local neighbours are visited) and depth-first sampling (where distant neighbours are visited) by introducing the following two parameters: Return parameter (p): Controls the likelihood of immediately revisiting a node in the walk. Setting it to a high value encourages moderate exploration, while setting it to a low value would keep the walk local. In-out parameter (q): Allows the search to differentiate between inward and outward nodes. Setting it to a high value biases the random walk towards local nodes, while setting it to a low value biases the walk to visit nodes which are further away. def next_step(graph, previous, current, p, q): neighbors = list(graph.neighbors(current)) weights = [] # Adjust the weights of the edges to the neighbors with respect to p and q. for neighbor in neighbors: if neighbor == previous: # Control the probability to return to the previous node. weights.append(graph[current][neighbor][\"weight\"] / p) elif graph.has_edge(neighbor, previous): # The probability of visiting a local node. weights.append(graph[current][neighbor][\"weight\"]) else: # Control the probability to move forward. weights.append(graph[current][neighbor][\"weight\"] / q) # Compute the probabilities of visiting each neighbor. weight_sum = sum(weights) probabilities = [weight / weight_sum for weight in weights] # Probabilistically select a neighbor to visit. next = np.random.choice(neighbors, size=1, p=probabilities)[0] return next def random_walk(graph, num_walks, num_steps, p, q): walks = [] nodes = list(graph.nodes()) # Perform multiple iterations of the random walk. for walk_iteration in range(num_walks): random.shuffle(nodes) for node in tqdm( nodes, position=0, leave=True, desc=f\"Random walks iteration {walk_iteration + 1} of {num_walks}\", ): # Start the walk with a random node from the graph. walk = [node] # Randomly walk for num_steps. while len(walk) < num_steps: current = walk[-1] previous = walk[-2] if len(walk) > 1 else None # Compute the next node to visit. next = next_step(graph, previous, current, p, q) walk.append(next) # Replace node ids (movie ids) in the walk with token ids. walk = [vocabulary_lookup[token] for token in walk] # Add the walk to the generated sequence. walks.append(walk) return walks Generate training data using the biased random walk You can explore different configurations of p and q to different results of related movies. # Random walk return parameter. p = 1 # Random walk in-out parameter. q = 1 # Number of iterations of random walks. num_walks = 5 # Number of steps of each random walk. num_steps = 10 walks = random_walk(movies_graph, num_walks, num_steps, p, q) print(\"Number of walks generated:\", len(walks)) Random walks iteration 1 of 5: 100%|██████████| 1405/1405 [00:04<00:00, 296.67it/s] Random walks iteration 2 of 5: 100%|██████████| 1405/1405 [00:05<00:00, 274.60it/s] Random walks iteration 3 of 5: 100%|██████████| 1405/1405 [00:04<00:00, 281.69it/s] Random walks iteration 4 of 5: 100%|██████████| 1405/1405 [00:04<00:00, 285.56it/s] Random walks iteration 5 of 5: 100%|██████████| 1405/1405 [00:04<00:00, 301.79it/s] Number of walks generated: 7025 Generate positive and negative examples To train a skip-gram model, we use the generated walks to create positive and negative training examples. Each example includes the following features: target: A movie in a walk sequence. context: Another movie in a walk sequence. weight: How many times these two movies occured in walk sequences. label: The label is 1 if these two movies are samples from the walk sequences, otherwise (i.e., if randomly sampled) the label is 0. Generate examples def generate_examples(sequences, window_size, num_negative_samples, vocabulary_size): example_weights = defaultdict(int) # Iterate over all sequences (walks). for sequence in tqdm( sequences, position=0, leave=True, desc=f\"Generating postive and negative examples\", ): # Generate positive and negative skip-gram pairs for a sequence (walk). pairs, labels = keras.preprocessing.sequence.skipgrams( sequence, vocabulary_size=vocabulary_size, window_size=window_size, negative_samples=num_negative_samples, ) for idx in range(len(pairs)): pair = pairs[idx] label = labels[idx] target, context = min(pair[0], pair[1]), max(pair[0], pair[1]) if target == context: continue entry = (target, context, label) example_weights[entry] += 1 targets, contexts, labels, weights = [], [], [], [] for entry in example_weights: weight = example_weights[entry] target, context, label = entry targets.append(target) contexts.append(context) labels.append(label) weights.append(weight) return np.array(targets), np.array(contexts), np.array(labels), np.array(weights) num_negative_samples = 4 targets, contexts, labels, weights = generate_examples( sequences=walks, window_size=num_steps, num_negative_samples=num_negative_samples, vocabulary_size=len(vocabulary), ) Generating postive and negative examples: 100%|██████████| 7025/7025 [00:11<00:00, 638.29it/s] Let's display the shapes of the outputs print(f\"Targets shape: {targets.shape}\") print(f\"Contexts shape: {contexts.shape}\") print(f\"Labels shape: {labels.shape}\") print(f\"Weights shape: {weights.shape}\") Targets shape: (880170,) Contexts shape: (880170,) Labels shape: (880170,) Weights shape: (880170,) Convert the data into tf.data.Dataset objects batch_size = 1024 def create_dataset(targets, contexts, labels, weights, batch_size): inputs = { \"target\": targets, \"context\": contexts, } dataset = tf.data.Dataset.from_tensor_slices((inputs, labels, weights)) dataset = dataset.shuffle(buffer_size=batch_size * 2) dataset = dataset.batch(batch_size, drop_remainder=True) dataset = dataset.prefetch(tf.data.AUTOTUNE) return dataset dataset = create_dataset( targets=targets, contexts=contexts, labels=labels, weights=weights, batch_size=batch_size, ) Train the skip-gram model Our skip-gram is a simple binary classification model that works as follows: An embedding is looked up for the target movie. An embedding is looked up for the context movie. The dot product is computed between these two embeddings. The result (after a sigmoid activation) is compared to the label. A binary crossentropy loss is used. learning_rate = 0.001 embedding_dim = 50 num_epochs = 10 Implement the model def create_model(vocabulary_size, embedding_dim): inputs = { \"target\": layers.Input(name=\"target\", shape=(), dtype=\"int32\"), \"context\": layers.Input(name=\"context\", shape=(), dtype=\"int32\"), } # Initialize item embeddings. embed_item = layers.Embedding( input_dim=vocabulary_size, output_dim=embedding_dim, embeddings_initializer=\"he_normal\", embeddings_regularizer=keras.regularizers.l2(1e-6), name=\"item_embeddings\", ) # Lookup embeddings for target. target_embeddings = embed_item(inputs[\"target\"]) # Lookup embeddings for context. context_embeddings = embed_item(inputs[\"context\"]) # Compute dot similarity between target and context embeddings. logits = layers.Dot(axes=1, normalize=False, name=\"dot_similarity\")( [target_embeddings, context_embeddings] ) # Create the model. model = keras.Model(inputs=inputs, outputs=logits) return model Train the model We instantiate the model and compile it. model = create_model(len(vocabulary), embedding_dim) model.compile( optimizer=keras.optimizers.Adam(learning_rate), loss=keras.losses.BinaryCrossentropy(from_logits=True), ) Let's plot the model. keras.utils.plot_model( model, show_shapes=True, show_dtype=True, show_layer_names=True, ) ('Failed to import pydot. You must `pip install pydot` and install graphviz (https://graphviz.gitlab.io/download/), ', 'for `pydotprint` to work.') Now we train the model on the dataset. history = model.fit(dataset, epochs=num_epochs) Epoch 1/10 859/859 [==============================] - 3s 3ms/step - loss: 3.4761 Epoch 2/10 859/859 [==============================] - 2s 3ms/step - loss: 3.3149 Epoch 3/10 859/859 [==============================] - 2s 3ms/step - loss: 3.2930 Epoch 4/10 859/859 [==============================] - 3s 3ms/step - loss: 3.2771 Epoch 5/10 859/859 [==============================] - 2s 3ms/step - loss: 3.2673 Epoch 6/10 859/859 [==============================] - 2s 3ms/step - loss: 3.2592 Epoch 7/10 859/859 [==============================] - 2s 3ms/step - loss: 3.2508 Epoch 8/10 859/859 [==============================] - 3s 3ms/step - loss: 3.2418 Epoch 9/10 859/859 [==============================] - 2s 3ms/step - loss: 3.2354 Epoch 10/10 859/859 [==============================] - 3s 3ms/step - loss: 3.2273 Finally we plot the learning history. plt.plot(history.history[\"loss\"]) plt.ylabel(\"loss\") plt.xlabel(\"epoch\") plt.show() png Analyze the learnt embeddings. movie_embeddings = model.get_layer(\"item_embeddings\").get_weights()[0] print(\"Embeddings shape:\", movie_embeddings.shape) Embeddings shape: (1406, 50) Find related movies Define a list with some movies called query_movies. query_movies = [ \"Matrix, The (1999)\", \"Star Wars: Episode IV - A New Hope (1977)\", \"Lion King, The (1994)\", \"Terminator 2: Judgment Day (1991)\", \"Godfather, The (1972)\", ] Get the embeddings of the movies in query_movies. query_embeddings = [] for movie_title in query_movies: movieId = get_movie_id_by_title(movie_title) token_id = vocabulary_lookup[movieId] movie_embedding = movie_embeddings[token_id] query_embeddings.append(movie_embedding) query_embeddings = np.array(query_embeddings) Compute the consine similarity between the embeddings of query_movies and all the other movies, then pick the top k for each. similarities = tf.linalg.matmul( tf.math.l2_normalize(query_embeddings), tf.math.l2_normalize(movie_embeddings), transpose_b=True, ) _, indices = tf.math.top_k(similarities, k=5) indices = indices.numpy().tolist() Display the top related movies in query_movies. for idx, title in enumerate(query_movies): print(title) print(\"\".rjust(len(title), \"-\")) similar_tokens = indices[idx] for token in similar_tokens: similar_movieId = vocabulary[token] similar_title = get_movie_title_by_id(similar_movieId) print(f\"- {similar_title}\") print() Matrix, The (1999) ------------------ - Matrix, The (1999) - Inception (2010) - Dark Knight, The (2008) - Back to the Future (1985) - Lord of the Rings: The Fellowship of the Ring, The (2001) Star Wars: Episode IV - A New Hope (1977) ----------------------------------------- - Star Wars: Episode V - The Empire Strikes Back (1980) - Star Wars: Episode IV - A New Hope (1977) - Back to the Future (1985) - Matrix, The (1999) - Star Wars: Episode VI - Return of the Jedi (1983) Lion King, The (1994) --------------------- - Lion King, The (1994) - Beauty and the Beast (1991) - Jurassic Park (1993) - Mrs. Doubtfire (1993) - Independence Day (a.k.a. ID4) (1996) Terminator 2: Judgment Day (1991) --------------------------------- - Terminator 2: Judgment Day (1991) - Star Wars: Episode VI - Return of the Jedi (1983) - Apollo 13 (1995) - Star Wars: Episode V - The Empire Strikes Back (1980) - Braveheart (1995) Godfather, The (1972) --------------------- - Godfather, The (1972) - Reservoir Dogs (1992) - Apocalypse Now (1979) - Fargo (1996) - American Beauty (1999) Visualize the embeddings using the Embedding Projector import io out_v = io.open(\"embeddings.tsv\", \"w\", encoding=\"utf-8\") out_m = io.open(\"metadata.tsv\", \"w\", encoding=\"utf-8\") for idx, movie_id in enumerate(vocabulary[1:]): movie_title = list(movies[movies.movieId == movie_id].title)[0] vector = movie_embeddings[idx] out_v.write(\"\t\".join([str(x) for x in vector]) + \"\n\") out_m.write(movie_title + \"\n\") out_v.close() out_m.close() Download the embeddings.tsv and metadata.tsv to analyze the obtained embeddings in the Embedding Projector. Implementation of an MPNN to predict blood-brain barrier permeability. Introduction In this tutorial, we will implement a type of graph neural network (GNN) known as _ message passing neural network_ (MPNN) to predict graph properties. Specifically, we will implement an MPNN to predict a molecular property known as blood-brain barrier permeability (BBBP). Motivation: as molecules are naturally represented as an undirected graph G = (V, E), where V is a set or vertices (nodes; atoms) and E a set of edges (bonds), GNNs (such as MPNN) are proving to be a useful method for predicting molecular properties. Until now, more traditional methods, such as random forests, support vector machines, etc., have been commonly used to predict molecular properties. In contrast to GNNs, these traditional approaches often operate on precomputed molecular features such as molecular weight, polarity, charge, number of carbon atoms, etc. Although these molecular features prove to be good predictors for various molecular properties, it is hypothesized that operating on these more \"raw\", \"low-level\", features could prove even better. References In recent years, a lot of effort has been put into developing neural networks for graph data, including molecular graphs. For a summary of graph neural networks, see e.g., A Comprehensive Survey on Graph Neural Networks and Graph Neural Networks: A Review of Methods and Applications; and for further reading on the specific graph neural network implemented in this tutorial see Neural Message Passing for Quantum Chemistry and DeepChem's MPNNModel. Setup Install RDKit and other dependencies (Text below taken from this tutorial). RDKit is a collection of cheminformatics and machine-learning software written in C++ and Python. In this tutorial, RDKit is used to conveniently and efficiently transform SMILES to molecule objects, and then from those obtain sets of atoms and bonds. SMILES expresses the structure of a given molecule in the form of an ASCII string. The SMILES string is a compact encoding which, for smaller molecules, is relatively human-readable. Encoding molecules as a string both alleviates and facilitates database and/or web searching of a given molecule. RDKit uses algorithms to accurately transform a given SMILES to a molecule object, which can then be used to compute a great number of molecular properties/features. Notice, RDKit is commonly installed via Conda. However, thanks to rdkit_platform_wheels, rdkit can now (for the sake of this tutorial) be installed easily via pip, as follows: pip -q install rdkit-pypi And for easy and efficient reading of csv files and visualization, the below needs to be installed: pip -q install pandas pip -q install Pillow pip -q install matplotlib pip -q install pydot sudo apt-get -qq install graphviz Import packages import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import numpy as np import pandas as pd import matplotlib.pyplot as plt import warnings from rdkit import Chem from rdkit import RDLogger from rdkit.Chem.Draw import IPythonConsole from rdkit.Chem.Draw import MolsToGridImage import logging tf.get_logger().setLevel(logging.ERROR) warnings.filterwarnings(\"ignore\") RDLogger.DisableLog(\"rdApp.*\") np.random.seed(42) tf.random.set_seed(42) Dataset Information about the dataset can be found in A Bayesian Approach to in Silico Blood-Brain Barrier Penetration Modeling and MoleculeNet: A Benchmark for Molecular Machine Learning. The dataset will be downloaded from MoleculeNet.ai. About The dataset contains 2,050 molecules. Each molecule come with a name, label and SMILES string. The blood-brain barrier (BBB) is a membrane separating the blood from the brain extracellular fluid, hence blocking out most drugs (molecules) from reaching the brain. Because of this, the BBBP has been important to study for the development of new drugs that aim to target the central nervous system. The labels for this data set are binary (1 or 0) and indicate the permeability of the molecules. csv_path = keras.utils.get_file( \"BBBP.csv\", \"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/BBBP.csv\" ) df = pd.read_csv(csv_path, usecols=[1, 2, 3]) df.iloc[96:104] name p_np smiles 96 cefoxitin 1 CO[C@]1(NC(=O)Cc2sccc2)[C@H]3SCC(=C(N3C1=O)C(O... 97 Org34167 1 NC(CC=C)c1ccccc1c2noc3c2cccc3 98 9-OH Risperidone 1 OC1C(N2CCC1)=NC(C)=C(CCN3CCC(CC3)c4c5ccc(F)cc5... 99 acetaminophen 1 CC(=O)Nc1ccc(O)cc1 100 acetylsalicylate 0 CC(=O)Oc1ccccc1C(O)=O 101 allopurinol 0 O=C1N=CN=C2NNC=C12 102 Alprostadil 0 CCCCC[C@H](O)/C=C/[C@H]1[C@H](O)CC(=O)[C@@H]1C... 103 aminophylline 0 CN1C(=O)N(C)c2nc[nH]c2C1=O.CN3C(=O)N(C)c4nc[nH... Define features To encode features for atoms and bonds (which we will need later), we'll define two classes: AtomFeaturizer and BondFeatuzier respectively. To reduce the lines of code, i.e., to keep this tutorial short and concise, only about a handful of (atom and bond) features will be considered: [atom features] symbol (element), number of valence electrons, number of hydrogen bonds, orbital hybridization, [bond features] (covalent) bond type, and conjugation. class Featurizer: def __init__(self, allowable_sets): self.dim = 0 self.features_mapping = {} for k, s in allowable_sets.items(): s = sorted(list(s)) self.features_mapping[k] = dict(zip(s, range(self.dim, len(s) + self.dim))) self.dim += len(s) def encode(self, inputs): output = np.zeros((self.dim,)) for name_feature, feature_mapping in self.features_mapping.items(): feature = getattr(self, name_feature)(inputs) if feature not in feature_mapping: continue output[feature_mapping[feature]] = 1.0 return output class AtomFeaturizer(Featurizer): def __init__(self, allowable_sets): super().__init__(allowable_sets) def symbol(self, atom): return atom.GetSymbol() def n_valence(self, atom): return atom.GetTotalValence() def n_hydrogens(self, atom): return atom.GetTotalNumHs() def hybridization(self, atom): return atom.GetHybridization().name.lower() class BondFeaturizer(Featurizer): def __init__(self, allowable_sets): super().__init__(allowable_sets) self.dim += 1 def encode(self, bond): output = np.zeros((self.dim,)) if bond is None: output[-1] = 1.0 return output output = super().encode(bond) return output def bond_type(self, bond): return bond.GetBondType().name.lower() def conjugated(self, bond): return bond.GetIsConjugated() atom_featurizer = AtomFeaturizer( allowable_sets={ \"symbol\": {\"B\", \"Br\", \"C\", \"Ca\", \"Cl\", \"F\", \"H\", \"I\", \"N\", \"Na\", \"O\", \"P\", \"S\"}, \"n_valence\": {0, 1, 2, 3, 4, 5, 6}, \"n_hydrogens\": {0, 1, 2, 3, 4}, \"hybridization\": {\"s\", \"sp\", \"sp2\", \"sp3\"}, } ) bond_featurizer = BondFeaturizer( allowable_sets={ \"bond_type\": {\"single\", \"double\", \"triple\", \"aromatic\"}, \"conjugated\": {True, False}, } ) Generate graphs Before we can generate complete graphs from SMILES, we need to implement the following functions: molecule_from_smiles, which takes as input a SMILES and returns a molecule object. This is all handled by RDKit. graph_from_molecule, which takes as input a molecule object and returns a graph, represented as a three-tuple (atom_features, bond_features, pair_indices). For this we will make use of the classes defined previously. Finally, we can now implement the function graphs_from_smiles, which applies function (1) and subsequently (2) on all SMILES of the training, validation and test datasets. Notice: although scaffold splitting is recommended for this data set (see here), for simplicity, simple random splittings were performed. def molecule_from_smiles(smiles): # MolFromSmiles(m, sanitize=True) should be equivalent to # MolFromSmiles(m, sanitize=False) -> SanitizeMol(m) -> AssignStereochemistry(m, ...) molecule = Chem.MolFromSmiles(smiles, sanitize=False) # If sanitization is unsuccessful, catch the error, and try again without # the sanitization step that caused the error flag = Chem.SanitizeMol(molecule, catchErrors=True) if flag != Chem.SanitizeFlags.SANITIZE_NONE: Chem.SanitizeMol(molecule, sanitizeOps=Chem.SanitizeFlags.SANITIZE_ALL ^ flag) Chem.AssignStereochemistry(molecule, cleanIt=True, force=True) return molecule def graph_from_molecule(molecule): # Initialize graph atom_features = [] bond_features = [] pair_indices = [] for atom in molecule.GetAtoms(): atom_features.append(atom_featurizer.encode(atom)) # Add self-loop. Notice, this also helps against some edge cases where the # last node has no edges. Alternatively, if no self-loops are used, for these # edge cases, zero-padding on the output of the edge network is needed. pair_indices.append([atom.GetIdx(), atom.GetIdx()]) bond_features.append(bond_featurizer.encode(None)) atom_neighbors = atom.GetNeighbors() for neighbor in atom_neighbors: bond = molecule.GetBondBetweenAtoms(atom.GetIdx(), neighbor.GetIdx()) pair_indices.append([atom.GetIdx(), neighbor.GetIdx()]) bond_features.append(bond_featurizer.encode(bond)) return np.array(atom_features), np.array(bond_features), np.array(pair_indices) def graphs_from_smiles(smiles_list): # Initialize graphs atom_features_list = [] bond_features_list = [] pair_indices_list = [] for smiles in smiles_list: molecule = molecule_from_smiles(smiles) atom_features, bond_features, pair_indices = graph_from_molecule(molecule) atom_features_list.append(atom_features) bond_features_list.append(bond_features) pair_indices_list.append(pair_indices) # Convert lists to ragged tensors for tf.data.Dataset later on return ( tf.ragged.constant(atom_features_list, dtype=tf.float32), tf.ragged.constant(bond_features_list, dtype=tf.float32), tf.ragged.constant(pair_indices_list, dtype=tf.int64), ) # Shuffle array of indices ranging from 0 to 2049 permuted_indices = np.random.permutation(np.arange(df.shape[0])) # Train set: 80 % of data train_index = permuted_indices[: int(df.shape[0] * 0.8)] x_train = graphs_from_smiles(df.iloc[train_index].smiles) y_train = df.iloc[train_index].p_np # Valid set: 19 % of data valid_index = permuted_indices[int(df.shape[0] * 0.8) : int(df.shape[0] * 0.99)] x_valid = graphs_from_smiles(df.iloc[valid_index].smiles) y_valid = df.iloc[valid_index].p_np # Test set: 1 % of data test_index = permuted_indices[int(df.shape[0] * 0.99) :] x_test = graphs_from_smiles(df.iloc[test_index].smiles) y_test = df.iloc[test_index].p_np Test the functions print(f\"Name:\t{df.name[100]}\nSMILES:\t{df.smiles[100]}\nBBBP:\t{df.p_np[100]}\") molecule = molecule_from_smiles(df.iloc[100].smiles) print(\"Molecule:\") molecule Name: acetylsalicylate SMILES: CC(=O)Oc1ccccc1C(O)=O BBBP: 0 Molecule: png graph = graph_from_molecule(molecule) print(\"Graph (including self-loops):\") print(\"\tatom features\t\", graph[0].shape) print(\"\tbond features\t\", graph[1].shape) print(\"\tpair indices\t\", graph[2].shape) Graph (including self-loops): atom features (13, 29) bond features (39, 7) pair indices (39, 2) Create a tf.data.Dataset In this tutorial, the MPNN implementation will take as input (per iteration) a single graph. Therefore, given a batch of (sub)graphs (molecules), we need to merge them into a single graph (we'll refer to this graph as global graph). This global graph is a disconnected graph where each subgraph is completely separated from the other subgraphs. def prepare_batch(x_batch, y_batch): \"\"\"Merges (sub)graphs of batch into a single global (disconnected) graph \"\"\" atom_features, bond_features, pair_indices = x_batch # Obtain number of atoms and bonds for each graph (molecule) num_atoms = atom_features.row_lengths() num_bonds = bond_features.row_lengths() # Obtain partition indices. atom_partition_indices will be used to # gather (sub)graphs from global graph in model later on molecule_indices = tf.range(len(num_atoms)) atom_partition_indices = tf.repeat(molecule_indices, num_atoms) bond_partition_indices = tf.repeat(molecule_indices[:-1], num_bonds[1:]) # Merge (sub)graphs into a global (disconnected) graph. Adding 'increment' to # 'pair_indices' (and merging ragged tensors) actualizes the global graph increment = tf.cumsum(num_atoms[:-1]) increment = tf.pad( tf.gather(increment, bond_partition_indices), [(num_bonds[0], 0)] ) pair_indices = pair_indices.merge_dims(outer_axis=0, inner_axis=1).to_tensor() pair_indices = pair_indices + increment[:, tf.newaxis] atom_features = atom_features.merge_dims(outer_axis=0, inner_axis=1).to_tensor() bond_features = bond_features.merge_dims(outer_axis=0, inner_axis=1).to_tensor() return (atom_features, bond_features, pair_indices, atom_partition_indices), y_batch def MPNNDataset(X, y, batch_size=32, shuffle=False): dataset = tf.data.Dataset.from_tensor_slices((X, (y))) if shuffle: dataset = dataset.shuffle(1024) return dataset.batch(batch_size).map(prepare_batch, -1) Model The MPNN model can take on various shapes and forms. In this tutorial, we will implement an MPNN based on the original paper Neural Message Passing for Quantum Chemistry and DeepChem's MPNNModel. The MPNN of this tutorial consists of three stages: message passing, readout and classification. Message passing The message passing step itself consists of two parts: The edge network, which passes messages from 1-hop neighbors w^{t}_{i} of v^{t} to v^{t}, based on the edge features between them (e_{v^{t}w^{t}_{i}}, where t = 0), resulting in an updated node state v^{t+1}. _{i} denotes the i:th neighbor of v^{t} and ^{t} the t:th state of v or w. An important feature of the edge network (in contrast to e.g. the relational graph convolutional network) is that it allows for non-discrete edge features. However, in this tutorial, only discrete edge features will be used. The gated recurrent unit (GRU), which takes as input the most recent node state (e.g., v^{t+1}) and updates it based on previous node state(s) (e.g., v^{t}). In other words, the most recent node states serves as the input to the GRU, while the previous node state(s) are incorporated within the memory state of the GRU. Importantly, step (1) and (2) are repeated for k steps, and where at each step 1...k, the radius (or # hops) of aggregated information from the source node v increases by 1. class EdgeNetwork(layers.Layer): def __init__(self, **kwargs): super().__init__(**kwargs) def build(self, input_shape): self.atom_dim = input_shape[0][-1] self.bond_dim = input_shape[1][-1] self.kernel = self.add_weight( shape=(self.bond_dim, self.atom_dim * self.atom_dim), trainable=True, initializer=\"glorot_uniform\", ) self.bias = self.add_weight( shape=(self.atom_dim * self.atom_dim), trainable=True, initializer=\"zeros\", ) self.built = True def call(self, inputs): atom_features, bond_features, pair_indices = inputs # Apply linear transformation to bond features bond_features = tf.matmul(bond_features, self.kernel) + self.bias # Reshape for neighborhood aggregation later bond_features = tf.reshape(bond_features, (-1, self.atom_dim, self.atom_dim)) # Obtain atom features of neighbors atom_features_neighbors = tf.gather(atom_features, pair_indices[:, 1]) atom_features_neighbors = tf.expand_dims(atom_features_neighbors, axis=-1) # Apply neighborhood aggregation transformed_features = tf.matmul(bond_features, atom_features_neighbors) transformed_features = tf.squeeze(transformed_features, axis=-1) aggregated_features = tf.math.segment_sum( transformed_features, pair_indices[:, 0] ) return aggregated_features class MessagePassing(layers.Layer): def __init__(self, units, steps=4, **kwargs): super().__init__(**kwargs) self.units = units self.steps = steps def build(self, input_shape): self.atom_dim = input_shape[0][-1] self.message_step = EdgeNetwork() self.pad_length = max(0, self.units - self.atom_dim) self.update_step = layers.GRUCell(self.atom_dim + self.pad_length) self.built = True def call(self, inputs): atom_features, bond_features, pair_indices = inputs # Pad atom features if number of desired units exceeds atom_features dim atom_features_updated = tf.pad(atom_features, [(0, 0), (0, self.pad_length)]) # Perform a number of steps of message passing for i in range(self.steps): # Aggregate atom_features from neighbors atom_features_aggregated = self.message_step( [atom_features_updated, bond_features, pair_indices] ) # Update aggregated atom_features via a step of GRU atom_features_updated, _ = self.update_step( atom_features_aggregated, atom_features_updated ) return atom_features_updated Readout When the message passing procedure ends, the k-step-aggregated node states are to be partitioned into subgraphs (correspoding to each molecule in the batch) and subsequently reduced to graph-level embeddings. In the original paper, a set-to-set layer was used for this purpose. In this tutorial however, a transformer encoder will be used. Specifically: the k-step-aggregated node states will be partitioned into the subgraphs (corresponding to each molecule in the batch); each subgraph will then be padded to match the subgraph with the greatest number of nodes, followed by a tf.stack(...); the (stacked) padded tensor, encoding subgraphs (each subgraph containing sets of node states), are masked to make sure the paddings don't interfere with training; finally, the padded tensor is passed to the transformer followed by an average pooling. class PartitionPadding(layers.Layer): def __init__(self, batch_size, **kwargs): super().__init__(**kwargs) self.batch_size = batch_size def call(self, inputs): atom_features, atom_partition_indices = inputs # Obtain subgraphs atom_features = tf.dynamic_partition( atom_features, atom_partition_indices, self.batch_size ) # Pad and stack subgraphs num_atoms = [tf.shape(f)[0] for f in atom_features] max_num_atoms = tf.reduce_max(num_atoms) atom_features_padded = tf.stack( [ tf.pad(f, [(0, max_num_atoms - n), (0, 0)]) for f, n in zip(atom_features, num_atoms) ], axis=0, ) # Remove empty subgraphs (usually for last batch) nonempty_examples = tf.where(tf.reduce_sum(atom_features_padded, (1, 2)) != 0) nonempty_examples = tf.squeeze(nonempty_examples, axis=-1) return tf.gather(atom_features_padded, nonempty_examples, axis=0) class TransformerEncoder(layers.Layer): def __init__(self, num_heads=8, embed_dim=64, dense_dim=512, **kwargs): super().__init__(**kwargs) self.attention = layers.MultiHeadAttention(num_heads, embed_dim) self.dense_proj = keras.Sequential( [layers.Dense(dense_dim, activation=\"relu\"), layers.Dense(embed_dim),] ) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() self.supports_masking = True def call(self, inputs, mask=None): attention_mask = mask[:, tf.newaxis, :] if mask is not None else None attention_output = self.attention(inputs, inputs, attention_mask=attention_mask) proj_input = self.layernorm_1(inputs + attention_output) return self.layernorm_2(proj_input + self.dense_proj(proj_input)) Message Passing Neural Network (MPNN) It is now time to complete the MPNN model. In addition to the message passing and readout, a two-layer classification network will be implemented to make predictions of BBBP. def MPNNModel( atom_dim, bond_dim, batch_size=32, message_units=64, message_steps=4, num_attention_heads=8, dense_units=512, ): atom_features = layers.Input((atom_dim), dtype=\"float32\", name=\"atom_features\") bond_features = layers.Input((bond_dim), dtype=\"float32\", name=\"bond_features\") pair_indices = layers.Input((2), dtype=\"int32\", name=\"pair_indices\") atom_partition_indices = layers.Input( (), dtype=\"int32\", name=\"atom_partition_indices\" ) x = MessagePassing(message_units, message_steps)( [atom_features, bond_features, pair_indices] ) x = PartitionPadding(batch_size)([x, atom_partition_indices]) x = layers.Masking()(x) x = TransformerEncoder(num_attention_heads, message_units, dense_units)(x) x = layers.GlobalAveragePooling1D()(x) x = layers.Dense(dense_units, activation=\"relu\")(x) x = layers.Dense(1, activation=\"sigmoid\")(x) model = keras.Model( inputs=[atom_features, bond_features, pair_indices, atom_partition_indices], outputs=[x], ) return model mpnn = MPNNModel( atom_dim=x_train[0][0][0].shape[0], bond_dim=x_train[1][0][0].shape[0], ) mpnn.compile( loss=keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adam(learning_rate=5e-4), metrics=[keras.metrics.AUC(name=\"AUC\")], ) keras.utils.plot_model(mpnn, show_dtype=True, show_shapes=True) png Training train_dataset = MPNNDataset(x_train, y_train) valid_dataset = MPNNDataset(x_valid, y_valid) test_dataset = MPNNDataset(x_test, y_test) history = mpnn.fit( train_dataset, validation_data=valid_dataset, epochs=40, verbose=2, class_weight={0: 2.0, 1: 0.5}, ) plt.figure(figsize=(10, 6)) plt.plot(history.history[\"AUC\"], label=\"train AUC\") plt.plot(history.history[\"val_AUC\"], label=\"valid AUC\") plt.xlabel(\"Epochs\", fontsize=16) plt.ylabel(\"AUC\", fontsize=16) plt.legend(fontsize=16) Epoch 1/40 52/52 - 4s - loss: 0.5240 - AUC: 0.7202 - val_loss: 0.5523 - val_AUC: 0.8310 Epoch 2/40 52/52 - 1s - loss: 0.4704 - AUC: 0.7899 - val_loss: 0.5592 - val_AUC: 0.8381 Epoch 3/40 52/52 - 1s - loss: 0.4529 - AUC: 0.8088 - val_loss: 0.5911 - val_AUC: 0.8406 Epoch 4/40 52/52 - 1s - loss: 0.4385 - AUC: 0.8224 - val_loss: 0.5379 - val_AUC: 0.8435 Epoch 5/40 52/52 - 1s - loss: 0.4256 - AUC: 0.8348 - val_loss: 0.4765 - val_AUC: 0.8473 Epoch 6/40 52/52 - 1s - loss: 0.4143 - AUC: 0.8448 - val_loss: 0.4760 - val_AUC: 0.8518 Epoch 7/40 52/52 - 1s - loss: 0.3968 - AUC: 0.8600 - val_loss: 0.4917 - val_AUC: 0.8592 Epoch 8/40 52/52 - 1s - loss: 0.3823 - AUC: 0.8716 - val_loss: 0.5301 - val_AUC: 0.8607 Epoch 9/40 52/52 - 1s - loss: 0.3724 - AUC: 0.8785 - val_loss: 0.5795 - val_AUC: 0.8632 Epoch 10/40 52/52 - 1s - loss: 0.3610 - AUC: 0.8878 - val_loss: 0.6460 - val_AUC: 0.8655 Epoch 11/40 52/52 - 1s - loss: 0.3491 - AUC: 0.8956 - val_loss: 0.6604 - val_AUC: 0.8685 Epoch 12/40 52/52 - 1s - loss: 0.3311 - AUC: 0.9076 - val_loss: 0.6075 - val_AUC: 0.8745 Epoch 13/40 52/52 - 1s - loss: 0.3162 - AUC: 0.9165 - val_loss: 0.5659 - val_AUC: 0.8832 Epoch 14/40 52/52 - 1s - loss: 0.3214 - AUC: 0.9131 - val_loss: 0.6581 - val_AUC: 0.8886 Epoch 15/40 52/52 - 1s - loss: 0.3064 - AUC: 0.9213 - val_loss: 0.6957 - val_AUC: 0.8884 Epoch 16/40 52/52 - 1s - loss: 0.2999 - AUC: 0.9246 - val_loss: 0.7201 - val_AUC: 0.8868 Epoch 17/40 52/52 - 1s - loss: 0.2825 - AUC: 0.9338 - val_loss: 0.8034 - val_AUC: 0.8850 Epoch 18/40 52/52 - 1s - loss: 0.2813 - AUC: 0.9337 - val_loss: 0.8026 - val_AUC: 0.8812 Epoch 19/40 52/52 - 1s - loss: 0.2725 - AUC: 0.9376 - val_loss: 0.8710 - val_AUC: 0.8867 Epoch 20/40 52/52 - 1s - loss: 0.2698 - AUC: 0.9378 - val_loss: 0.8262 - val_AUC: 0.8959 Epoch 21/40 52/52 - 1s - loss: 0.2729 - AUC: 0.9358 - val_loss: 0.7017 - val_AUC: 0.8970 Epoch 22/40 52/52 - 1s - loss: 0.2707 - AUC: 0.9376 - val_loss: 0.5759 - val_AUC: 0.8897 Epoch 23/40 52/52 - 1s - loss: 0.2562 - AUC: 0.9440 - val_loss: 0.4482 - val_AUC: 0.8945 Epoch 24/40 52/52 - 1s - loss: 0.2693 - AUC: 0.9387 - val_loss: 0.4220 - val_AUC: 0.8944 Epoch 25/40 52/52 - 1s - loss: 0.2753 - AUC: 0.9356 - val_loss: 0.5671 - val_AUC: 0.9081 Epoch 26/40 52/52 - 1s - loss: 0.2315 - AUC: 0.9538 - val_loss: 0.4307 - val_AUC: 0.9105 Epoch 27/40 52/52 - 1s - loss: 0.2269 - AUC: 0.9545 - val_loss: 0.4037 - val_AUC: 0.9084 Epoch 28/40 52/52 - 1s - loss: 0.2318 - AUC: 0.9528 - val_loss: 0.4394 - val_AUC: 0.9133 Epoch 29/40 52/52 - 1s - loss: 0.2162 - AUC: 0.9584 - val_loss: 0.4683 - val_AUC: 0.9199 Epoch 30/40 52/52 - 1s - loss: 0.2038 - AUC: 0.9622 - val_loss: 0.4301 - val_AUC: 0.9186 Epoch 31/40 52/52 - 1s - loss: 0.1924 - AUC: 0.9656 - val_loss: 0.3870 - val_AUC: 0.9253 Epoch 32/40 52/52 - 1s - loss: 0.2012 - AUC: 0.9632 - val_loss: 0.4105 - val_AUC: 0.9164 Epoch 33/40 52/52 - 1s - loss: 0.2030 - AUC: 0.9624 - val_loss: 0.3595 - val_AUC: 0.9175 Epoch 34/40 52/52 - 1s - loss: 0.2041 - AUC: 0.9625 - val_loss: 0.3983 - val_AUC: 0.9116 Epoch 35/40 52/52 - 1s - loss: 0.2017 - AUC: 0.9631 - val_loss: 0.3790 - val_AUC: 0.9220 Epoch 36/40 52/52 - 1s - loss: 0.1986 - AUC: 0.9640 - val_loss: 0.3593 - val_AUC: 0.9289 Epoch 37/40 52/52 - 1s - loss: 0.1892 - AUC: 0.9657 - val_loss: 0.3663 - val_AUC: 0.9235 Epoch 38/40 52/52 - 1s - loss: 0.1948 - AUC: 0.9632 - val_loss: 0.4329 - val_AUC: 0.9160 Epoch 39/40 52/52 - 1s - loss: 0.1734 - AUC: 0.9701 - val_loss: 0.3298 - val_AUC: 0.9263 Epoch 40/40 52/52 - 1s - loss: 0.1800 - AUC: 0.9690 - val_loss: 0.3345 - val_AUC: 0.9246 png Predicting molecules = [molecule_from_smiles(df.smiles.values[index]) for index in test_index] y_true = [df.p_np.values[index] for index in test_index] y_pred = tf.squeeze(mpnn.predict(test_dataset), axis=1) legends = [f\"y_true/y_pred = {y_true[i]}/{y_pred[i]:.2f}\" for i in range(len(y_true))] MolsToGridImage(molecules, molsPerRow=4, legends=legends) png Conclusions In this tutorial, we demonstarted a message passing neural network (MPNN) to predict blood-brain barrier permeability (BBBP) for a number of different molecules. We first had to construct graphs from SMILES, and then build a Keras model that could operate on these graphs. Implementing a graph neural network for predicting the topic of a paper given citations. Introduction Many datasets in various machine learning (ML) applications have structural relationships between their entities, which can be represented as graphs. Such application includes social and communication networks analysis, traffic prediction, and fraud detection. Graph representation Learning aims to build and train models for graph datasets to be used for a variety of ML tasks. This example demonstrate a simple implementation of a Graph Neural Network (GNN) model. The model is used for a node prediction task on the Cora dataset to predict the subject of a paper given its words and citations network. Note that, we implement a Graph Convolution Layer from scratch to provide better understanding of how they work. However, there is a number of specialized TensorFlow-based libraries that provide rich GNN APIs, such as Spectral, StellarGraph, and GraphNets. Setup import os import pandas as pd import numpy as np import networkx as nx import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Prepare the Dataset The Cora dataset consists of 2,708 scientific papers classified into one of seven classes. The citation network consists of 5,429 links. Each paper has a binary word vector of size 1,433, indicating the presence of a corresponding word. Download the dataset The dataset has two tap-separated files: cora.cites and cora.content. The cora.cites includes the citation records with two columns: cited_paper_id (target) and citing_paper_id (source). The cora.content includes the paper content records with 1,435 columns: paper_id, subject, and 1,433 binary features. Let's download the dataset. zip_file = keras.utils.get_file( fname=\"cora.tgz\", origin=\"https://linqs-data.soe.ucsc.edu/public/lbc/cora.tgz\", extract=True, ) data_dir = os.path.join(os.path.dirname(zip_file), \"cora\") Process and visualize the dataset Then we load the citations data into a Pandas DataFrame. citations = pd.read_csv( os.path.join(data_dir, \"cora.cites\"), sep=\"\t\", header=None, names=[\"target\", \"source\"], ) print(\"Citations shape:\", citations.shape) Citations shape: (5429, 2) Now we display a sample of the citations DataFrame. The target column includes the paper ids cited by the paper ids in the source column. citations.sample(frac=1).head() target source 2581 28227 6169 1500 7297 7276 1194 6184 1105718 4221 139738 1108834 3707 79809 1153275 Now let's load the papers data into a Pandas DataFrame. column_names = [\"paper_id\"] + [f\"term_{idx}\" for idx in range(1433)] + [\"subject\"] papers = pd.read_csv( os.path.join(data_dir, \"cora.content\"), sep=\"\t\", header=None, names=column_names, ) print(\"Papers shape:\", papers.shape) Papers shape: (2708, 1435) Now we display a sample of the papers DataFrame. The DataFrame includes the paper_id and the subject columns, as well as 1,433 binary column representing whether a term exists in the paper or not. print(papers.sample(5).T) 1 133 2425 paper_id 1061127 34355 1108389 term_0 0 0 0 term_1 0 0 0 term_2 0 0 0 term_3 0 0 0 ... ... ... ... term_1429 0 0 0 term_1430 0 0 0 term_1431 0 0 0 term_1432 0 0 0 subject Rule_Learning Neural_Networks Probabilistic_Methods 2103 1346 paper_id 1153942 80491 term_0 0 0 term_1 0 0 term_2 1 0 term_3 0 0 ... ... ... term_1429 0 0 term_1430 0 0 term_1431 0 0 term_1432 0 0 subject Genetic_Algorithms Neural_Networks [1435 rows x 5 columns] Let's display the count of the papers in each subject. print(papers.subject.value_counts()) Neural_Networks 818 Probabilistic_Methods 426 Genetic_Algorithms 418 Theory 351 Case_Based 298 Reinforcement_Learning 217 Rule_Learning 180 Name: subject, dtype: int64 We convert the paper ids and the subjects into zero-based indices. class_values = sorted(papers[\"subject\"].unique()) class_idx = {name: id for id, name in enumerate(class_values)} paper_idx = {name: idx for idx, name in enumerate(sorted(papers[\"paper_id\"].unique()))} papers[\"paper_id\"] = papers[\"paper_id\"].apply(lambda name: paper_idx[name]) citations[\"source\"] = citations[\"source\"].apply(lambda name: paper_idx[name]) citations[\"target\"] = citations[\"target\"].apply(lambda name: paper_idx[name]) papers[\"subject\"] = papers[\"subject\"].apply(lambda value: class_idx[value]) Now let's visualize the citation graph. Each node in the graph represents a paper, and the color of the node corresponds to its subject. Note that we only show a sample of the papers in the dataset. plt.figure(figsize=(10, 10)) colors = papers[\"subject\"].tolist() cora_graph = nx.from_pandas_edgelist(citations.sample(n=1500)) subjects = list(papers[papers[\"paper_id\"].isin(list(cora_graph.nodes))][\"subject\"]) nx.draw_spring(cora_graph, node_size=15, node_color=subjects) png Split the dataset into stratified train and test sets train_data, test_data = [], [] for _, group_data in papers.groupby(\"subject\"): # Select around 50% of the dataset for training. random_selection = np.random.rand(len(group_data.index)) <= 0.5 train_data.append(group_data[random_selection]) test_data.append(group_data[~random_selection]) train_data = pd.concat(train_data).sample(frac=1) test_data = pd.concat(test_data).sample(frac=1) print(\"Train data shape:\", train_data.shape) print(\"Test data shape:\", test_data.shape) Train data shape: (1360, 1435) Test data shape: (1348, 1435) Implement Train and Evaluate Experiment hidden_units = [32, 32] learning_rate = 0.01 dropout_rate = 0.5 num_epochs = 300 batch_size = 256 This function compiles and trains an input model using the given training data. def run_experiment(model, x_train, y_train): # Compile the model. model.compile( optimizer=keras.optimizers.Adam(learning_rate), loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=[keras.metrics.SparseCategoricalAccuracy(name=\"acc\")], ) # Create an early stopping callback. early_stopping = keras.callbacks.EarlyStopping( monitor=\"val_acc\", patience=50, restore_best_weights=True ) # Fit the model. history = model.fit( x=x_train, y=y_train, epochs=num_epochs, batch_size=batch_size, validation_split=0.15, callbacks=[early_stopping], ) return history This function displays the loss and accuracy curves of the model during training. def display_learning_curves(history): fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5)) ax1.plot(history.history[\"loss\"]) ax1.plot(history.history[\"val_loss\"]) ax1.legend([\"train\", \"test\"], loc=\"upper right\") ax1.set_xlabel(\"Epochs\") ax1.set_ylabel(\"Loss\") ax2.plot(history.history[\"acc\"]) ax2.plot(history.history[\"val_acc\"]) ax2.legend([\"train\", \"test\"], loc=\"upper right\") ax2.set_xlabel(\"Epochs\") ax2.set_ylabel(\"Accuracy\") plt.show() Implement Feedforward Network (FFN) Module We will use this module in the baseline and the GNN models. def create_ffn(hidden_units, dropout_rate, name=None): fnn_layers = [] for units in hidden_units: fnn_layers.append(layers.BatchNormalization()) fnn_layers.append(layers.Dropout(dropout_rate)) fnn_layers.append(layers.Dense(units, activation=tf.nn.gelu)) return keras.Sequential(fnn_layers, name=name) Build a Baseline Neural Network Model Prepare the data for the baseline model feature_names = set(papers.columns) - {\"paper_id\", \"subject\"} num_features = len(feature_names) num_classes = len(class_idx) # Create train and test features as a numpy array. x_train = train_data[feature_names].to_numpy() x_test = test_data[feature_names].to_numpy() # Create train and test targets as a numpy array. y_train = train_data[\"subject\"] y_test = test_data[\"subject\"] Implement a baseline classifier We add five FFN blocks with skip connections, so that we generate a baseline model with roughly the same number of parameters as the GNN models to be built later. def create_baseline_model(hidden_units, num_classes, dropout_rate=0.2): inputs = layers.Input(shape=(num_features,), name=\"input_features\") x = create_ffn(hidden_units, dropout_rate, name=f\"ffn_block1\")(inputs) for block_idx in range(4): # Create an FFN block. x1 = create_ffn(hidden_units, dropout_rate, name=f\"ffn_block{block_idx + 2}\")(x) # Add skip connection. x = layers.Add(name=f\"skip_connection{block_idx + 2}\")([x, x1]) # Compute logits. logits = layers.Dense(num_classes, name=\"logits\")(x) # Create the model. return keras.Model(inputs=inputs, outputs=logits, name=\"baseline\") baseline_model = create_baseline_model(hidden_units, num_classes, dropout_rate) baseline_model.summary() Model: \"baseline\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_features (InputLayer) [(None, 1433)] 0 __________________________________________________________________________________________________ ffn_block1 (Sequential) (None, 32) 52804 input_features[0][0] __________________________________________________________________________________________________ ffn_block2 (Sequential) (None, 32) 2368 ffn_block1[0][0] __________________________________________________________________________________________________ skip_connection2 (Add) (None, 32) 0 ffn_block1[0][0] ffn_block2[0][0] __________________________________________________________________________________________________ ffn_block3 (Sequential) (None, 32) 2368 skip_connection2[0][0] __________________________________________________________________________________________________ skip_connection3 (Add) (None, 32) 0 skip_connection2[0][0] ffn_block3[0][0] __________________________________________________________________________________________________ ffn_block4 (Sequential) (None, 32) 2368 skip_connection3[0][0] __________________________________________________________________________________________________ skip_connection4 (Add) (None, 32) 0 skip_connection3[0][0] ffn_block4[0][0] __________________________________________________________________________________________________ ffn_block5 (Sequential) (None, 32) 2368 skip_connection4[0][0] __________________________________________________________________________________________________ skip_connection5 (Add) (None, 32) 0 skip_connection4[0][0] ffn_block5[0][0] __________________________________________________________________________________________________ logits (Dense) (None, 7) 231 skip_connection5[0][0] ================================================================================================== Total params: 62,507 Trainable params: 59,065 Non-trainable params: 3,442 __________________________________________________________________________________________________ Train the baseline classifier history = run_experiment(baseline_model, x_train, y_train) Epoch 1/300 5/5 [==============================] - 3s 203ms/step - loss: 4.1695 - acc: 0.1660 - val_loss: 1.9008 - val_acc: 0.3186 Epoch 2/300 5/5 [==============================] - 0s 15ms/step - loss: 2.9269 - acc: 0.2630 - val_loss: 1.8906 - val_acc: 0.3235 Epoch 3/300 5/5 [==============================] - 0s 15ms/step - loss: 2.5669 - acc: 0.2424 - val_loss: 1.8713 - val_acc: 0.3186 Epoch 4/300 5/5 [==============================] - 0s 15ms/step - loss: 2.1377 - acc: 0.3147 - val_loss: 1.8687 - val_acc: 0.3529 Epoch 5/300 5/5 [==============================] - 0s 15ms/step - loss: 2.0256 - acc: 0.3297 - val_loss: 1.8285 - val_acc: 0.3235 Epoch 6/300 5/5 [==============================] - 0s 15ms/step - loss: 1.8148 - acc: 0.3495 - val_loss: 1.8000 - val_acc: 0.3235 Epoch 7/300 5/5 [==============================] - 0s 15ms/step - loss: 1.7216 - acc: 0.3883 - val_loss: 1.7771 - val_acc: 0.3333 Epoch 8/300 5/5 [==============================] - 0s 15ms/step - loss: 1.6941 - acc: 0.3910 - val_loss: 1.7528 - val_acc: 0.3284 Epoch 9/300 5/5 [==============================] - 0s 15ms/step - loss: 1.5690 - acc: 0.4358 - val_loss: 1.7128 - val_acc: 0.3333 Epoch 10/300 5/5 [==============================] - 0s 15ms/step - loss: 1.5139 - acc: 0.4367 - val_loss: 1.6650 - val_acc: 0.3676 Epoch 11/300 5/5 [==============================] - 0s 15ms/step - loss: 1.4370 - acc: 0.4930 - val_loss: 1.6145 - val_acc: 0.3775 Epoch 12/300 5/5 [==============================] - 0s 15ms/step - loss: 1.3696 - acc: 0.5109 - val_loss: 1.5787 - val_acc: 0.3873 Epoch 13/300 5/5 [==============================] - 0s 15ms/step - loss: 1.3979 - acc: 0.5341 - val_loss: 1.5564 - val_acc: 0.3922 Epoch 14/300 5/5 [==============================] - 0s 15ms/step - loss: 1.2681 - acc: 0.5599 - val_loss: 1.5547 - val_acc: 0.3922 Epoch 15/300 5/5 [==============================] - 0s 16ms/step - loss: 1.1970 - acc: 0.5807 - val_loss: 1.5735 - val_acc: 0.3873 Epoch 16/300 5/5 [==============================] - 0s 15ms/step - loss: 1.1555 - acc: 0.6032 - val_loss: 1.5131 - val_acc: 0.4216 Epoch 17/300 5/5 [==============================] - 0s 15ms/step - loss: 1.1234 - acc: 0.6130 - val_loss: 1.4385 - val_acc: 0.4608 Epoch 18/300 5/5 [==============================] - 0s 14ms/step - loss: 1.0507 - acc: 0.6306 - val_loss: 1.3929 - val_acc: 0.4804 Epoch 19/300 5/5 [==============================] - 0s 15ms/step - loss: 1.0341 - acc: 0.6393 - val_loss: 1.3628 - val_acc: 0.4902 Epoch 20/300 5/5 [==============================] - 0s 35ms/step - loss: 0.9457 - acc: 0.6693 - val_loss: 1.3383 - val_acc: 0.4902 Epoch 21/300 5/5 [==============================] - 0s 17ms/step - loss: 0.9054 - acc: 0.6756 - val_loss: 1.3365 - val_acc: 0.4951 Epoch 22/300 5/5 [==============================] - 0s 15ms/step - loss: 0.8952 - acc: 0.6854 - val_loss: 1.3228 - val_acc: 0.5049 Epoch 23/300 5/5 [==============================] - 0s 15ms/step - loss: 0.8413 - acc: 0.7217 - val_loss: 1.2924 - val_acc: 0.5294 Epoch 24/300 5/5 [==============================] - 0s 15ms/step - loss: 0.8543 - acc: 0.6998 - val_loss: 1.2379 - val_acc: 0.5490 Epoch 25/300 5/5 [==============================] - 0s 16ms/step - loss: 0.7632 - acc: 0.7376 - val_loss: 1.1516 - val_acc: 0.5833 Epoch 26/300 5/5 [==============================] - 0s 15ms/step - loss: 0.7189 - acc: 0.7496 - val_loss: 1.1296 - val_acc: 0.5931 Epoch 27/300 5/5 [==============================] - 0s 15ms/step - loss: 0.7433 - acc: 0.7482 - val_loss: 1.0937 - val_acc: 0.6127 Epoch 28/300 5/5 [==============================] - 0s 15ms/step - loss: 0.7310 - acc: 0.7440 - val_loss: 1.0950 - val_acc: 0.5980 Epoch 29/300 5/5 [==============================] - 0s 16ms/step - loss: 0.7059 - acc: 0.7654 - val_loss: 1.1343 - val_acc: 0.5882 Epoch 30/300 5/5 [==============================] - 0s 21ms/step - loss: 0.6831 - acc: 0.7645 - val_loss: 1.1938 - val_acc: 0.5686 Epoch 31/300 5/5 [==============================] - 0s 23ms/step - loss: 0.6741 - acc: 0.7788 - val_loss: 1.1281 - val_acc: 0.5931 Epoch 32/300 5/5 [==============================] - 0s 16ms/step - loss: 0.6344 - acc: 0.7753 - val_loss: 1.0870 - val_acc: 0.6029 Epoch 33/300 5/5 [==============================] - 0s 16ms/step - loss: 0.6052 - acc: 0.7876 - val_loss: 1.0947 - val_acc: 0.6127 Epoch 34/300 5/5 [==============================] - 0s 15ms/step - loss: 0.6313 - acc: 0.7908 - val_loss: 1.1186 - val_acc: 0.5882 Epoch 35/300 5/5 [==============================] - 0s 16ms/step - loss: 0.6163 - acc: 0.7955 - val_loss: 1.0899 - val_acc: 0.6176 Epoch 36/300 5/5 [==============================] - 0s 16ms/step - loss: 0.5388 - acc: 0.8203 - val_loss: 1.1222 - val_acc: 0.5882 Epoch 37/300 5/5 [==============================] - 0s 16ms/step - loss: 0.5487 - acc: 0.8080 - val_loss: 1.0205 - val_acc: 0.6127 Epoch 38/300 5/5 [==============================] - 0s 16ms/step - loss: 0.5885 - acc: 0.7903 - val_loss: 0.9268 - val_acc: 0.6569 Epoch 39/300 5/5 [==============================] - 0s 15ms/step - loss: 0.5541 - acc: 0.8025 - val_loss: 0.9367 - val_acc: 0.6471 Epoch 40/300 5/5 [==============================] - 0s 36ms/step - loss: 0.5594 - acc: 0.7935 - val_loss: 0.9688 - val_acc: 0.6275 Epoch 41/300 5/5 [==============================] - 0s 17ms/step - loss: 0.5255 - acc: 0.8169 - val_loss: 1.0076 - val_acc: 0.6324 Epoch 42/300 5/5 [==============================] - 0s 16ms/step - loss: 0.5284 - acc: 0.8180 - val_loss: 1.0106 - val_acc: 0.6373 Epoch 43/300 5/5 [==============================] - 0s 15ms/step - loss: 0.5141 - acc: 0.8188 - val_loss: 0.8842 - val_acc: 0.6912 Epoch 44/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4767 - acc: 0.8342 - val_loss: 0.8249 - val_acc: 0.7108 Epoch 45/300 5/5 [==============================] - 0s 15ms/step - loss: 0.5915 - acc: 0.8055 - val_loss: 0.8567 - val_acc: 0.6912 Epoch 46/300 5/5 [==============================] - 0s 15ms/step - loss: 0.5026 - acc: 0.8357 - val_loss: 0.9287 - val_acc: 0.6618 Epoch 47/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4859 - acc: 0.8304 - val_loss: 0.9044 - val_acc: 0.6667 Epoch 48/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4860 - acc: 0.8440 - val_loss: 0.8672 - val_acc: 0.6912 Epoch 49/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4723 - acc: 0.8358 - val_loss: 0.8717 - val_acc: 0.6863 Epoch 50/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4831 - acc: 0.8457 - val_loss: 0.8674 - val_acc: 0.6912 Epoch 51/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4873 - acc: 0.8353 - val_loss: 0.8587 - val_acc: 0.7010 Epoch 52/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4537 - acc: 0.8472 - val_loss: 0.8544 - val_acc: 0.7059 Epoch 53/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4684 - acc: 0.8425 - val_loss: 0.8423 - val_acc: 0.7206 Epoch 54/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4436 - acc: 0.8523 - val_loss: 0.8607 - val_acc: 0.6961 Epoch 55/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4589 - acc: 0.8335 - val_loss: 0.8462 - val_acc: 0.7059 Epoch 56/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4757 - acc: 0.8360 - val_loss: 0.8415 - val_acc: 0.7010 Epoch 57/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4270 - acc: 0.8593 - val_loss: 0.8094 - val_acc: 0.7255 Epoch 58/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4530 - acc: 0.8307 - val_loss: 0.8357 - val_acc: 0.7108 Epoch 59/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4370 - acc: 0.8453 - val_loss: 0.8804 - val_acc: 0.7108 Epoch 60/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4379 - acc: 0.8465 - val_loss: 0.8791 - val_acc: 0.7108 Epoch 61/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4254 - acc: 0.8615 - val_loss: 0.8355 - val_acc: 0.7059 Epoch 62/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3929 - acc: 0.8696 - val_loss: 0.8355 - val_acc: 0.7304 Epoch 63/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4039 - acc: 0.8516 - val_loss: 0.8576 - val_acc: 0.7353 Epoch 64/300 5/5 [==============================] - 0s 35ms/step - loss: 0.4220 - acc: 0.8596 - val_loss: 0.8848 - val_acc: 0.7059 Epoch 65/300 5/5 [==============================] - 0s 17ms/step - loss: 0.4091 - acc: 0.8521 - val_loss: 0.8560 - val_acc: 0.7108 Epoch 66/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4658 - acc: 0.8470 - val_loss: 0.8518 - val_acc: 0.7206 Epoch 67/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4269 - acc: 0.8437 - val_loss: 0.7878 - val_acc: 0.7255 Epoch 68/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4368 - acc: 0.8438 - val_loss: 0.7859 - val_acc: 0.7255 Epoch 69/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4113 - acc: 0.8452 - val_loss: 0.8056 - val_acc: 0.7402 Epoch 70/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4304 - acc: 0.8469 - val_loss: 0.8093 - val_acc: 0.7451 Epoch 71/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4159 - acc: 0.8585 - val_loss: 0.8090 - val_acc: 0.7451 Epoch 72/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4218 - acc: 0.8610 - val_loss: 0.8028 - val_acc: 0.7402 Epoch 73/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3632 - acc: 0.8714 - val_loss: 0.8153 - val_acc: 0.7304 Epoch 74/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3745 - acc: 0.8722 - val_loss: 0.8299 - val_acc: 0.7402 Epoch 75/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3997 - acc: 0.8680 - val_loss: 0.8445 - val_acc: 0.7255 Epoch 76/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4143 - acc: 0.8620 - val_loss: 0.8344 - val_acc: 0.7206 Epoch 77/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4006 - acc: 0.8616 - val_loss: 0.8358 - val_acc: 0.7255 Epoch 78/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4266 - acc: 0.8532 - val_loss: 0.8266 - val_acc: 0.7206 Epoch 79/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4337 - acc: 0.8523 - val_loss: 0.8181 - val_acc: 0.7206 Epoch 80/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3857 - acc: 0.8624 - val_loss: 0.8143 - val_acc: 0.7206 Epoch 81/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4146 - acc: 0.8567 - val_loss: 0.8192 - val_acc: 0.7108 Epoch 82/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3638 - acc: 0.8794 - val_loss: 0.8248 - val_acc: 0.7206 Epoch 83/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4126 - acc: 0.8678 - val_loss: 0.8565 - val_acc: 0.7255 Epoch 84/300 5/5 [==============================] - 0s 36ms/step - loss: 0.3941 - acc: 0.8530 - val_loss: 0.8624 - val_acc: 0.7206 Epoch 85/300 5/5 [==============================] - 0s 17ms/step - loss: 0.3843 - acc: 0.8786 - val_loss: 0.8389 - val_acc: 0.7255 Epoch 86/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3651 - acc: 0.8747 - val_loss: 0.8314 - val_acc: 0.7206 Epoch 87/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3911 - acc: 0.8657 - val_loss: 0.8736 - val_acc: 0.7255 Epoch 88/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3706 - acc: 0.8714 - val_loss: 0.9159 - val_acc: 0.7108 Epoch 89/300 5/5 [==============================] - 0s 15ms/step - loss: 0.4403 - acc: 0.8386 - val_loss: 0.9038 - val_acc: 0.7206 Epoch 90/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3865 - acc: 0.8668 - val_loss: 0.8733 - val_acc: 0.7206 Epoch 91/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3757 - acc: 0.8643 - val_loss: 0.8704 - val_acc: 0.7157 Epoch 92/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3828 - acc: 0.8669 - val_loss: 0.8786 - val_acc: 0.7157 Epoch 93/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3651 - acc: 0.8787 - val_loss: 0.8977 - val_acc: 0.7206 Epoch 94/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3913 - acc: 0.8614 - val_loss: 0.9415 - val_acc: 0.7206 Epoch 95/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3995 - acc: 0.8590 - val_loss: 0.9495 - val_acc: 0.7157 Epoch 96/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4228 - acc: 0.8508 - val_loss: 0.9490 - val_acc: 0.7059 Epoch 97/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3853 - acc: 0.8789 - val_loss: 0.9402 - val_acc: 0.7157 Epoch 98/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3711 - acc: 0.8812 - val_loss: 0.9283 - val_acc: 0.7206 Epoch 99/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3949 - acc: 0.8578 - val_loss: 0.9591 - val_acc: 0.7108 Epoch 100/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3563 - acc: 0.8780 - val_loss: 0.9744 - val_acc: 0.7206 Epoch 101/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3579 - acc: 0.8815 - val_loss: 0.9358 - val_acc: 0.7206 Epoch 102/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4069 - acc: 0.8698 - val_loss: 0.9245 - val_acc: 0.7157 Epoch 103/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3161 - acc: 0.8955 - val_loss: 0.9401 - val_acc: 0.7157 Epoch 104/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3346 - acc: 0.8910 - val_loss: 0.9517 - val_acc: 0.7157 Epoch 105/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4204 - acc: 0.8538 - val_loss: 0.9366 - val_acc: 0.7157 Epoch 106/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3492 - acc: 0.8821 - val_loss: 0.9424 - val_acc: 0.7353 Epoch 107/300 5/5 [==============================] - 0s 16ms/step - loss: 0.4002 - acc: 0.8604 - val_loss: 0.9842 - val_acc: 0.7157 Epoch 108/300 5/5 [==============================] - 0s 35ms/step - loss: 0.3701 - acc: 0.8736 - val_loss: 0.9999 - val_acc: 0.7010 Epoch 109/300 5/5 [==============================] - 0s 17ms/step - loss: 0.3391 - acc: 0.8866 - val_loss: 0.9768 - val_acc: 0.6961 Epoch 110/300 5/5 [==============================] - 0s 15ms/step - loss: 0.3857 - acc: 0.8739 - val_loss: 0.9953 - val_acc: 0.7255 Epoch 111/300 5/5 [==============================] - 0s 16ms/step - loss: 0.3822 - acc: 0.8731 - val_loss: 0.9817 - val_acc: 0.7255 Epoch 112/300 5/5 [==============================] - 0s 23ms/step - loss: 0.3211 - acc: 0.8887 - val_loss: 0.9781 - val_acc: 0.7108 Epoch 113/300 5/5 [==============================] - 0s 20ms/step - loss: 0.3473 - acc: 0.8715 - val_loss: 0.9927 - val_acc: 0.6912 Epoch 114/300 5/5 [==============================] - 0s 20ms/step - loss: 0.4026 - acc: 0.8621 - val_loss: 1.0002 - val_acc: 0.6863 Epoch 115/300 5/5 [==============================] - 0s 20ms/step - loss: 0.3413 - acc: 0.8837 - val_loss: 1.0031 - val_acc: 0.6912 Epoch 116/300 5/5 [==============================] - 0s 20ms/step - loss: 0.3653 - acc: 0.8765 - val_loss: 1.0065 - val_acc: 0.7010 Epoch 117/300 5/5 [==============================] - 0s 21ms/step - loss: 0.3147 - acc: 0.8974 - val_loss: 1.0206 - val_acc: 0.7059 Epoch 118/300 5/5 [==============================] - 0s 21ms/step - loss: 0.3639 - acc: 0.8783 - val_loss: 1.0206 - val_acc: 0.7010 Epoch 119/300 5/5 [==============================] - 0s 19ms/step - loss: 0.3660 - acc: 0.8696 - val_loss: 1.0260 - val_acc: 0.6912 Epoch 120/300 5/5 [==============================] - 0s 18ms/step - loss: 0.3624 - acc: 0.8708 - val_loss: 1.0619 - val_acc: 0.6814 Let's plot the learning curves. display_learning_curves(history) png Now we evaluate the baseline model on the test data split. _, test_accuracy = baseline_model.evaluate(x=x_test, y=y_test, verbose=0) print(f\"Test accuracy: {round(test_accuracy * 100, 2)}%\") Test accuracy: 73.52% Examine the baseline model predictions Let's create new data instances by randomly generating binary word vectors with respect to the word presence probabilities. def generate_random_instances(num_instances): token_probability = x_train.mean(axis=0) instances = [] for _ in range(num_instances): probabilities = np.random.uniform(size=len(token_probability)) instance = (probabilities <= token_probability).astype(int) instances.append(instance) return np.array(instances) def display_class_probabilities(probabilities): for instance_idx, probs in enumerate(probabilities): print(f\"Instance {instance_idx + 1}:\") for class_idx, prob in enumerate(probs): print(f\"- {class_values[class_idx]}: {round(prob * 100, 2)}%\") Now we show the baseline model predictions given these randomly generated instances. new_instances = generate_random_instances(num_classes) logits = baseline_model.predict(new_instances) probabilities = keras.activations.softmax(tf.convert_to_tensor(logits)).numpy() display_class_probabilities(probabilities) Instance 1: - Case_Based: 13.02% - Genetic_Algorithms: 6.89% - Neural_Networks: 23.32% - Probabilistic_Methods: 47.89% - Reinforcement_Learning: 2.66% - Rule_Learning: 1.18% - Theory: 5.03% Instance 2: - Case_Based: 1.64% - Genetic_Algorithms: 59.74% - Neural_Networks: 27.13% - Probabilistic_Methods: 9.02% - Reinforcement_Learning: 1.05% - Rule_Learning: 0.12% - Theory: 1.31% Instance 3: - Case_Based: 1.35% - Genetic_Algorithms: 77.41% - Neural_Networks: 9.56% - Probabilistic_Methods: 7.89% - Reinforcement_Learning: 0.42% - Rule_Learning: 0.46% - Theory: 2.92% Instance 4: - Case_Based: 0.43% - Genetic_Algorithms: 3.87% - Neural_Networks: 92.88% - Probabilistic_Methods: 0.97% - Reinforcement_Learning: 0.56% - Rule_Learning: 0.09% - Theory: 1.2% Instance 5: - Case_Based: 0.11% - Genetic_Algorithms: 0.17% - Neural_Networks: 10.26% - Probabilistic_Methods: 0.5% - Reinforcement_Learning: 0.35% - Rule_Learning: 0.63% - Theory: 87.97% Instance 6: - Case_Based: 0.98% - Genetic_Algorithms: 23.37% - Neural_Networks: 70.76% - Probabilistic_Methods: 1.12% - Reinforcement_Learning: 2.23% - Rule_Learning: 0.21% - Theory: 1.33% Instance 7: - Case_Based: 0.64% - Genetic_Algorithms: 2.42% - Neural_Networks: 27.19% - Probabilistic_Methods: 14.07% - Reinforcement_Learning: 1.62% - Rule_Learning: 9.35% - Theory: 44.7% Build a Graph Neural Network Model Prepare the data for the graph model Preparing and loading the graphs data into the model for training is the most challenging part in GNN models, which is addressed in different ways by the specialised libraries. In this example, we show a simple approach for preparing and using graph data that is suitable if your dataset consists of a single graph that fits entirely in memory. The graph data is represented by the graph_info tuple, which consists of the following three elements: node_features: This is a [num_nodes, num_features] NumPy array that includes the node features. In this dataset, the nodes are the papers, and the node_features are the word-presence binary vectors of each paper. edges: This is [num_edges, num_edges] NumPy array representing a sparse adjacency matrix of the links between the nodes. In this example, the links are the citations between the papers. edge_weights (optional): This is a [num_edges] NumPy array that includes the edge weights, which quantify the relationships between nodes in the graph. In this example, there are no weights for the paper citations. # Create an edges array (sparse adjacency matrix) of shape [2, num_edges]. edges = citations[[\"source\", \"target\"]].to_numpy().T # Create an edge weights array of ones. edge_weights = tf.ones(shape=edges.shape[1]) # Create a node features array of shape [num_nodes, num_features]. node_features = tf.cast( papers.sort_values(\"paper_id\")[feature_names].to_numpy(), dtype=tf.dtypes.float32 ) # Create graph info tuple with node_features, edges, and edge_weights. graph_info = (node_features, edges, edge_weights) print(\"Edges shape:\", edges.shape) print(\"Nodes shape:\", node_features.shape) Edges shape: (2, 5429) Nodes shape: (2708, 1433) Implement a graph convolution layer We implement a graph convolution module as a Keras Layer. Our GraphConvLayer performs the following steps: Prepare: The input node representations are processed using a FFN to produce a message. You can simplify the processing by only applying linear transformation to the representations. Aggregate: The messages of the neighbours of each node are aggregated with respect to the edge_weights using a permutation invariant pooling operation, such as sum, mean, and max, to prepare a single aggregated message for each node. See, for example, tf.math.unsorted_segment_sum APIs used to aggregate neighbour messages. Update: The node_repesentations and aggregated_messages—both of shape [num_nodes, representation_dim]— are combined and processed to produce the new state of the node representations (node embeddings). If combination_type is gru, the node_repesentations and aggregated_messages are stacked to create a sequence, then processed by a GRU layer. Otherwise, the node_repesentations and aggregated_messages are added or concatenated, then processed using a FFN. The technique implemented use ideas from Graph Convolutional Networks, GraphSage, Graph Isomorphism Network, Simple Graph Networks, and Gated Graph Sequence Neural Networks. Two other key techniques that are not covered are Graph Attention Networks and Message Passing Neural Networks. class GraphConvLayer(layers.Layer): def __init__( self, hidden_units, dropout_rate=0.2, aggregation_type=\"mean\", combination_type=\"concat\", normalize=False, *args, **kwargs, ): super(GraphConvLayer, self).__init__(*args, **kwargs) self.aggregation_type = aggregation_type self.combination_type = combination_type self.normalize = normalize self.ffn_prepare = create_ffn(hidden_units, dropout_rate) if self.combination_type == \"gated\": self.update_fn = layers.GRU( units=hidden_units, activation=\"tanh\", recurrent_activation=\"sigmoid\", dropout=dropout_rate, return_state=True, recurrent_dropout=dropout_rate, ) else: self.update_fn = create_ffn(hidden_units, dropout_rate) def prepare(self, node_repesentations, weights=None): # node_repesentations shape is [num_edges, embedding_dim]. messages = self.ffn_prepare(node_repesentations) if weights is not None: messages = messages * tf.expand_dims(weights, -1) return messages def aggregate(self, node_indices, neighbour_messages): # node_indices shape is [num_edges]. # neighbour_messages shape: [num_edges, representation_dim]. num_nodes = tf.math.reduce_max(node_indices) + 1 if self.aggregation_type == \"sum\": aggregated_message = tf.math.unsorted_segment_sum( neighbour_messages, node_indices, num_segments=num_nodes ) elif self.aggregation_type == \"mean\": aggregated_message = tf.math.unsorted_segment_mean( neighbour_messages, node_indices, num_segments=num_nodes ) elif self.aggregation_type == \"max\": aggregated_message = tf.math.unsorted_segment_max( neighbour_messages, node_indices, num_segments=num_nodes ) else: raise ValueError(f\"Invalid aggregation type: {self.aggregation_type}.\") return aggregated_message def update(self, node_repesentations, aggregated_messages): # node_repesentations shape is [num_nodes, representation_dim]. # aggregated_messages shape is [num_nodes, representation_dim]. if self.combination_type == \"gru\": # Create a sequence of two elements for the GRU layer. h = tf.stack([node_repesentations, aggregated_messages], axis=1) elif self.combination_type == \"concat\": # Concatenate the node_repesentations and aggregated_messages. h = tf.concat([node_repesentations, aggregated_messages], axis=1) elif self.combination_type == \"add\": # Add node_repesentations and aggregated_messages. h = node_repesentations + aggregated_messages else: raise ValueError(f\"Invalid combination type: {self.combination_type}.\") # Apply the processing function. node_embeddings = self.update_fn(h) if self.combination_type == \"gru\": node_embeddings = tf.unstack(node_embeddings, axis=1)[-1] if self.normalize: node_embeddings = tf.nn.l2_normalize(node_embeddings, axis=-1) return node_embeddings def call(self, inputs): \"\"\"Process the inputs to produce the node_embeddings. inputs: a tuple of three elements: node_repesentations, edges, edge_weights. Returns: node_embeddings of shape [num_nodes, representation_dim]. \"\"\" node_repesentations, edges, edge_weights = inputs # Get node_indices (source) and neighbour_indices (target) from edges. node_indices, neighbour_indices = edges[0], edges[1] # neighbour_repesentations shape is [num_edges, representation_dim]. neighbour_repesentations = tf.gather(node_repesentations, neighbour_indices) # Prepare the messages of the neighbours. neighbour_messages = self.prepare(neighbour_repesentations, edge_weights) # Aggregate the neighbour messages. aggregated_messages = self.aggregate(node_indices, neighbour_messages) # Update the node embedding with the neighbour messages. return self.update(node_repesentations, aggregated_messages) Implement a graph neural network node classifier The GNN classification model follows the Design Space for Graph Neural Networks approach, as follows: Apply preprocessing using FFN to the node features to generate initial node representations. Apply one or more graph convolutional layer, with skip connections, to the node representation to produce node embeddings. Apply post-processing using FFN to the node embeddings to generat the final node embeddings. Feed the node embeddings in a Softmax layer to predict the node class. Each graph convolutional layer added captures information from a further level of neighbours. However, adding many graph convolutional layer can cause oversmoothing, where the model produces similar embeddings for all the nodes. Note that the graph_info passed to the constructor of the Keras model, and used as a property of the Keras model object, rather than input data for training or prediction. The model will accept a batch of node_indices, which are used to lookup the node features and neighbours from the graph_info. class GNNNodeClassifier(tf.keras.Model): def __init__( self, graph_info, num_classes, hidden_units, aggregation_type=\"sum\", combination_type=\"concat\", dropout_rate=0.2, normalize=True, *args, **kwargs, ): super(GNNNodeClassifier, self).__init__(*args, **kwargs) # Unpack graph_info to three elements: node_features, edges, and edge_weight. node_features, edges, edge_weights = graph_info self.node_features = node_features self.edges = edges self.edge_weights = edge_weights # Set edge_weights to ones if not provided. if self.edge_weights is None: self.edge_weights = tf.ones(shape=edges.shape[1]) # Scale edge_weights to sum to 1. self.edge_weights = self.edge_weights / tf.math.reduce_sum(self.edge_weights) # Create a process layer. self.preprocess = create_ffn(hidden_units, dropout_rate, name=\"preprocess\") # Create the first GraphConv layer. self.conv1 = GraphConvLayer( hidden_units, dropout_rate, aggregation_type, combination_type, normalize, name=\"graph_conv1\", ) # Create the second GraphConv layer. self.conv2 = GraphConvLayer( hidden_units, dropout_rate, aggregation_type, combination_type, normalize, name=\"graph_conv2\", ) # Create a postprocess layer. self.postprocess = create_ffn(hidden_units, dropout_rate, name=\"postprocess\") # Create a compute logits layer. self.compute_logits = layers.Dense(units=num_classes, name=\"logits\") def call(self, input_node_indices): # Preprocess the node_features to produce node representations. x = self.preprocess(self.node_features) # Apply the first graph conv layer. x1 = self.conv1((x, self.edges, self.edge_weights)) # Skip connection. x = x1 + x # Apply the second graph conv layer. x2 = self.conv2((x, self.edges, self.edge_weights)) # Skip connection. x = x2 + x # Postprocess node embedding. x = self.postprocess(x) # Fetch node embeddings for the input node_indices. node_embeddings = tf.gather(x, input_node_indices) # Compute logits return self.compute_logits(node_embeddings) Let's test instantiating and calling the GNN model. Notice that if you provide N node indices, the output will be a tensor of shape [N, num_classes], regardless of the size of the graph. gnn_model = GNNNodeClassifier( graph_info=graph_info, num_classes=num_classes, hidden_units=hidden_units, dropout_rate=dropout_rate, name=\"gnn_model\", ) print(\"GNN output shape:\", gnn_model([1, 10, 100])) gnn_model.summary() GNN output shape: tf.Tensor( [[ 0.00620723 0.06162593 0.0176599 0.00830251 -0.03019211 -0.00402163 0.00277454] [ 0.01705155 -0.0467547 0.01400987 -0.02146192 -0.11757397 0.10820404 -0.0375765 ] [-0.02516522 -0.05514468 -0.03842098 -0.0495692 -0.05128997 -0.02241635 -0.07738923]], shape=(3, 7), dtype=float32) Model: \"gnn_model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= preprocess (Sequential) (2708, 32) 52804 _________________________________________________________________ graph_conv1 (GraphConvLayer) multiple 5888 _________________________________________________________________ graph_conv2 (GraphConvLayer) multiple 5888 _________________________________________________________________ postprocess (Sequential) (2708, 32) 2368 _________________________________________________________________ logits (Dense) multiple 231 ================================================================= Total params: 67,179 Trainable params: 63,481 Non-trainable params: 3,698 _________________________________________________________________ Train the GNN model Note that we use the standard supervised cross-entropy loss to train the model. However, we can add another self-supervised loss term for the generated node embeddings that makes sure that neighbouring nodes in graph have similar representations, while faraway nodes have dissimilar representations. x_train = train_data.paper_id.to_numpy() history = run_experiment(gnn_model, x_train, y_train) Epoch 1/300 5/5 [==============================] - 4s 188ms/step - loss: 2.2529 - acc: 0.1793 - val_loss: 1.8933 - val_acc: 0.2941 Epoch 2/300 5/5 [==============================] - 0s 83ms/step - loss: 1.9866 - acc: 0.2601 - val_loss: 1.8753 - val_acc: 0.3186 Epoch 3/300 5/5 [==============================] - 0s 77ms/step - loss: 1.8794 - acc: 0.2846 - val_loss: 1.8655 - val_acc: 0.3186 Epoch 4/300 5/5 [==============================] - 0s 74ms/step - loss: 1.8432 - acc: 0.3078 - val_loss: 1.8529 - val_acc: 0.3186 Epoch 5/300 5/5 [==============================] - 0s 69ms/step - loss: 1.8314 - acc: 0.3134 - val_loss: 1.8429 - val_acc: 0.3186 Epoch 6/300 5/5 [==============================] - 0s 68ms/step - loss: 1.8157 - acc: 0.3208 - val_loss: 1.8326 - val_acc: 0.3186 Epoch 7/300 5/5 [==============================] - 0s 94ms/step - loss: 1.8112 - acc: 0.3071 - val_loss: 1.8265 - val_acc: 0.3186 Epoch 8/300 5/5 [==============================] - 0s 67ms/step - loss: 1.8028 - acc: 0.3132 - val_loss: 1.8171 - val_acc: 0.3186 Epoch 9/300 5/5 [==============================] - 0s 68ms/step - loss: 1.8007 - acc: 0.3206 - val_loss: 1.7961 - val_acc: 0.3186 Epoch 10/300 5/5 [==============================] - 0s 68ms/step - loss: 1.7571 - acc: 0.3259 - val_loss: 1.7623 - val_acc: 0.3186 Epoch 11/300 5/5 [==============================] - 0s 68ms/step - loss: 1.7373 - acc: 0.3279 - val_loss: 1.7131 - val_acc: 0.3186 Epoch 12/300 5/5 [==============================] - 0s 76ms/step - loss: 1.7130 - acc: 0.3169 - val_loss: 1.6552 - val_acc: 0.3186 Epoch 13/300 5/5 [==============================] - 0s 70ms/step - loss: 1.6989 - acc: 0.3315 - val_loss: 1.6075 - val_acc: 0.3284 Epoch 14/300 5/5 [==============================] - 0s 79ms/step - loss: 1.6733 - acc: 0.3522 - val_loss: 1.6027 - val_acc: 0.3333 Epoch 15/300 5/5 [==============================] - 0s 75ms/step - loss: 1.6060 - acc: 0.3641 - val_loss: 1.6422 - val_acc: 0.3480 Epoch 16/300 5/5 [==============================] - 0s 68ms/step - loss: 1.5783 - acc: 0.3924 - val_loss: 1.6893 - val_acc: 0.3676 Epoch 17/300 5/5 [==============================] - 0s 70ms/step - loss: 1.5269 - acc: 0.4315 - val_loss: 1.7534 - val_acc: 0.3725 Epoch 18/300 5/5 [==============================] - 0s 77ms/step - loss: 1.4558 - acc: 0.4633 - val_loss: 1.7224 - val_acc: 0.4167 Epoch 19/300 5/5 [==============================] - 0s 75ms/step - loss: 1.4131 - acc: 0.4765 - val_loss: 1.6482 - val_acc: 0.4510 Epoch 20/300 5/5 [==============================] - 0s 70ms/step - loss: 1.3880 - acc: 0.4859 - val_loss: 1.4956 - val_acc: 0.4706 Epoch 21/300 5/5 [==============================] - 0s 73ms/step - loss: 1.3223 - acc: 0.5166 - val_loss: 1.5299 - val_acc: 0.4853 Epoch 22/300 5/5 [==============================] - 0s 75ms/step - loss: 1.3226 - acc: 0.5172 - val_loss: 1.6304 - val_acc: 0.4902 Epoch 23/300 5/5 [==============================] - 0s 75ms/step - loss: 1.2888 - acc: 0.5267 - val_loss: 1.6679 - val_acc: 0.5000 Epoch 24/300 5/5 [==============================] - 0s 69ms/step - loss: 1.2478 - acc: 0.5279 - val_loss: 1.6552 - val_acc: 0.4853 Epoch 25/300 5/5 [==============================] - 0s 70ms/step - loss: 1.1978 - acc: 0.5720 - val_loss: 1.6705 - val_acc: 0.4902 Epoch 26/300 5/5 [==============================] - 0s 70ms/step - loss: 1.1814 - acc: 0.5596 - val_loss: 1.6327 - val_acc: 0.5343 Epoch 27/300 5/5 [==============================] - 0s 68ms/step - loss: 1.1085 - acc: 0.5979 - val_loss: 1.5184 - val_acc: 0.5245 Epoch 28/300 5/5 [==============================] - 0s 69ms/step - loss: 1.0695 - acc: 0.6078 - val_loss: 1.5212 - val_acc: 0.4853 Epoch 29/300 5/5 [==============================] - 0s 70ms/step - loss: 1.1063 - acc: 0.6002 - val_loss: 1.5988 - val_acc: 0.4706 Epoch 30/300 5/5 [==============================] - 0s 68ms/step - loss: 1.0194 - acc: 0.6326 - val_loss: 1.5636 - val_acc: 0.4951 Epoch 31/300 5/5 [==============================] - 0s 70ms/step - loss: 1.0320 - acc: 0.6268 - val_loss: 1.5191 - val_acc: 0.5196 Epoch 32/300 5/5 [==============================] - 0s 82ms/step - loss: 0.9749 - acc: 0.6433 - val_loss: 1.5922 - val_acc: 0.5098 Epoch 33/300 5/5 [==============================] - 0s 85ms/step - loss: 0.9095 - acc: 0.6717 - val_loss: 1.5879 - val_acc: 0.5000 Epoch 34/300 5/5 [==============================] - 0s 78ms/step - loss: 0.9324 - acc: 0.6903 - val_loss: 1.5717 - val_acc: 0.4951 Epoch 35/300 5/5 [==============================] - 0s 80ms/step - loss: 0.8908 - acc: 0.6953 - val_loss: 1.5010 - val_acc: 0.5098 Epoch 36/300 5/5 [==============================] - 0s 99ms/step - loss: 0.8858 - acc: 0.6977 - val_loss: 1.5939 - val_acc: 0.5147 Epoch 37/300 5/5 [==============================] - 0s 79ms/step - loss: 0.8376 - acc: 0.6991 - val_loss: 1.4000 - val_acc: 0.5833 Epoch 38/300 5/5 [==============================] - 0s 75ms/step - loss: 0.8657 - acc: 0.7080 - val_loss: 1.3288 - val_acc: 0.5931 Epoch 39/300 5/5 [==============================] - 0s 86ms/step - loss: 0.9160 - acc: 0.6819 - val_loss: 1.1358 - val_acc: 0.6275 Epoch 40/300 5/5 [==============================] - 0s 80ms/step - loss: 0.8676 - acc: 0.7109 - val_loss: 1.0618 - val_acc: 0.6765 Epoch 41/300 5/5 [==============================] - 0s 72ms/step - loss: 0.8065 - acc: 0.7246 - val_loss: 1.0785 - val_acc: 0.6765 Epoch 42/300 5/5 [==============================] - 0s 76ms/step - loss: 0.8478 - acc: 0.7145 - val_loss: 1.0502 - val_acc: 0.6569 Epoch 43/300 5/5 [==============================] - 0s 78ms/step - loss: 0.8125 - acc: 0.7068 - val_loss: 0.9888 - val_acc: 0.6520 Epoch 44/300 5/5 [==============================] - 0s 68ms/step - loss: 0.7791 - acc: 0.7425 - val_loss: 0.9820 - val_acc: 0.6618 Epoch 45/300 5/5 [==============================] - 0s 69ms/step - loss: 0.7492 - acc: 0.7368 - val_loss: 0.9297 - val_acc: 0.6961 Epoch 46/300 5/5 [==============================] - 0s 71ms/step - loss: 0.7521 - acc: 0.7668 - val_loss: 0.9757 - val_acc: 0.6961 Epoch 47/300 5/5 [==============================] - 0s 71ms/step - loss: 0.7090 - acc: 0.7587 - val_loss: 0.9676 - val_acc: 0.7059 Epoch 48/300 5/5 [==============================] - 0s 68ms/step - loss: 0.7008 - acc: 0.7430 - val_loss: 0.9457 - val_acc: 0.7010 Epoch 49/300 5/5 [==============================] - 0s 69ms/step - loss: 0.6919 - acc: 0.7584 - val_loss: 0.9998 - val_acc: 0.6569 Epoch 50/300 5/5 [==============================] - 0s 68ms/step - loss: 0.7583 - acc: 0.7628 - val_loss: 0.9707 - val_acc: 0.6667 Epoch 51/300 5/5 [==============================] - 0s 69ms/step - loss: 0.6575 - acc: 0.7697 - val_loss: 0.9260 - val_acc: 0.6814 Epoch 52/300 5/5 [==============================] - 0s 78ms/step - loss: 0.6751 - acc: 0.7774 - val_loss: 0.9173 - val_acc: 0.6765 Epoch 53/300 5/5 [==============================] - 0s 92ms/step - loss: 0.6964 - acc: 0.7561 - val_loss: 0.8985 - val_acc: 0.6961 Epoch 54/300 5/5 [==============================] - 0s 77ms/step - loss: 0.6386 - acc: 0.7872 - val_loss: 0.9455 - val_acc: 0.6961 Epoch 55/300 5/5 [==============================] - 0s 77ms/step - loss: 0.6110 - acc: 0.8130 - val_loss: 0.9780 - val_acc: 0.6716 Epoch 56/300 5/5 [==============================] - 0s 76ms/step - loss: 0.6483 - acc: 0.7703 - val_loss: 0.9650 - val_acc: 0.6863 Epoch 57/300 5/5 [==============================] - 0s 78ms/step - loss: 0.6811 - acc: 0.7706 - val_loss: 0.9446 - val_acc: 0.6667 Epoch 58/300 5/5 [==============================] - 0s 76ms/step - loss: 0.6391 - acc: 0.7852 - val_loss: 0.9059 - val_acc: 0.7010 Epoch 59/300 5/5 [==============================] - 0s 76ms/step - loss: 0.6533 - acc: 0.7784 - val_loss: 0.8964 - val_acc: 0.7108 Epoch 60/300 5/5 [==============================] - 0s 101ms/step - loss: 0.6587 - acc: 0.7863 - val_loss: 0.8417 - val_acc: 0.7108 Epoch 61/300 5/5 [==============================] - 0s 84ms/step - loss: 0.5776 - acc: 0.8166 - val_loss: 0.8035 - val_acc: 0.7304 Epoch 62/300 5/5 [==============================] - 0s 80ms/step - loss: 0.6396 - acc: 0.7792 - val_loss: 0.8072 - val_acc: 0.7500 Epoch 63/300 5/5 [==============================] - 0s 67ms/step - loss: 0.6201 - acc: 0.7972 - val_loss: 0.7809 - val_acc: 0.7696 Epoch 64/300 5/5 [==============================] - 0s 68ms/step - loss: 0.6358 - acc: 0.7875 - val_loss: 0.7635 - val_acc: 0.7500 Epoch 65/300 5/5 [==============================] - 0s 70ms/step - loss: 0.5914 - acc: 0.8027 - val_loss: 0.8147 - val_acc: 0.7402 Epoch 66/300 5/5 [==============================] - 0s 69ms/step - loss: 0.5960 - acc: 0.7955 - val_loss: 0.9350 - val_acc: 0.7304 Epoch 67/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5752 - acc: 0.8001 - val_loss: 0.9849 - val_acc: 0.7157 Epoch 68/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5189 - acc: 0.8322 - val_loss: 1.0268 - val_acc: 0.7206 Epoch 69/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5413 - acc: 0.8078 - val_loss: 0.9132 - val_acc: 0.7549 Epoch 70/300 5/5 [==============================] - 0s 75ms/step - loss: 0.5231 - acc: 0.8222 - val_loss: 0.8673 - val_acc: 0.7647 Epoch 71/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5416 - acc: 0.8219 - val_loss: 0.8179 - val_acc: 0.7696 Epoch 72/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5060 - acc: 0.8263 - val_loss: 0.7870 - val_acc: 0.7794 Epoch 73/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5502 - acc: 0.8221 - val_loss: 0.7749 - val_acc: 0.7549 Epoch 74/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5111 - acc: 0.8434 - val_loss: 0.7830 - val_acc: 0.7549 Epoch 75/300 5/5 [==============================] - 0s 69ms/step - loss: 0.5119 - acc: 0.8386 - val_loss: 0.8140 - val_acc: 0.7451 Epoch 76/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4922 - acc: 0.8433 - val_loss: 0.8149 - val_acc: 0.7353 Epoch 77/300 5/5 [==============================] - 0s 71ms/step - loss: 0.5217 - acc: 0.8188 - val_loss: 0.7784 - val_acc: 0.7598 Epoch 78/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5027 - acc: 0.8410 - val_loss: 0.7660 - val_acc: 0.7696 Epoch 79/300 5/5 [==============================] - 0s 67ms/step - loss: 0.5307 - acc: 0.8265 - val_loss: 0.7217 - val_acc: 0.7696 Epoch 80/300 5/5 [==============================] - 0s 68ms/step - loss: 0.5164 - acc: 0.8239 - val_loss: 0.6974 - val_acc: 0.7647 Epoch 81/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4404 - acc: 0.8526 - val_loss: 0.6891 - val_acc: 0.7745 Epoch 82/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4565 - acc: 0.8449 - val_loss: 0.6839 - val_acc: 0.7696 Epoch 83/300 5/5 [==============================] - 0s 67ms/step - loss: 0.4759 - acc: 0.8491 - val_loss: 0.7162 - val_acc: 0.7745 Epoch 84/300 5/5 [==============================] - 0s 70ms/step - loss: 0.5154 - acc: 0.8476 - val_loss: 0.7889 - val_acc: 0.7598 Epoch 85/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4847 - acc: 0.8480 - val_loss: 0.7579 - val_acc: 0.7794 Epoch 86/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4519 - acc: 0.8592 - val_loss: 0.7056 - val_acc: 0.7941 Epoch 87/300 5/5 [==============================] - 0s 67ms/step - loss: 0.5038 - acc: 0.8472 - val_loss: 0.6725 - val_acc: 0.7794 Epoch 88/300 5/5 [==============================] - 0s 92ms/step - loss: 0.4729 - acc: 0.8454 - val_loss: 0.7057 - val_acc: 0.7745 Epoch 89/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4811 - acc: 0.8562 - val_loss: 0.6784 - val_acc: 0.7990 Epoch 90/300 5/5 [==============================] - 0s 70ms/step - loss: 0.4102 - acc: 0.8779 - val_loss: 0.6383 - val_acc: 0.8039 Epoch 91/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4493 - acc: 0.8703 - val_loss: 0.6574 - val_acc: 0.7941 Epoch 92/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4560 - acc: 0.8610 - val_loss: 0.6764 - val_acc: 0.7941 Epoch 93/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4465 - acc: 0.8626 - val_loss: 0.6628 - val_acc: 0.7892 Epoch 94/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4773 - acc: 0.8446 - val_loss: 0.6573 - val_acc: 0.7941 Epoch 95/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4313 - acc: 0.8734 - val_loss: 0.6875 - val_acc: 0.7941 Epoch 96/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4668 - acc: 0.8598 - val_loss: 0.6712 - val_acc: 0.8039 Epoch 97/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4329 - acc: 0.8696 - val_loss: 0.6274 - val_acc: 0.8088 Epoch 98/300 5/5 [==============================] - 0s 71ms/step - loss: 0.4223 - acc: 0.8542 - val_loss: 0.6259 - val_acc: 0.7990 Epoch 99/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4677 - acc: 0.8488 - val_loss: 0.6431 - val_acc: 0.8186 Epoch 100/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3933 - acc: 0.8753 - val_loss: 0.6559 - val_acc: 0.8186 Epoch 101/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3945 - acc: 0.8777 - val_loss: 0.6461 - val_acc: 0.8186 Epoch 102/300 5/5 [==============================] - 0s 70ms/step - loss: 0.4671 - acc: 0.8324 - val_loss: 0.6607 - val_acc: 0.7990 Epoch 103/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3890 - acc: 0.8762 - val_loss: 0.6792 - val_acc: 0.7941 Epoch 104/300 5/5 [==============================] - 0s 67ms/step - loss: 0.4336 - acc: 0.8646 - val_loss: 0.6854 - val_acc: 0.7990 Epoch 105/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4304 - acc: 0.8651 - val_loss: 0.6949 - val_acc: 0.8039 Epoch 106/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4043 - acc: 0.8723 - val_loss: 0.6941 - val_acc: 0.7892 Epoch 107/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4043 - acc: 0.8713 - val_loss: 0.6798 - val_acc: 0.8088 Epoch 108/300 5/5 [==============================] - 0s 70ms/step - loss: 0.4647 - acc: 0.8599 - val_loss: 0.6726 - val_acc: 0.8039 Epoch 109/300 5/5 [==============================] - 0s 73ms/step - loss: 0.3916 - acc: 0.8820 - val_loss: 0.6680 - val_acc: 0.8137 Epoch 110/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3990 - acc: 0.8875 - val_loss: 0.6580 - val_acc: 0.8137 Epoch 111/300 5/5 [==============================] - 0s 95ms/step - loss: 0.4240 - acc: 0.8786 - val_loss: 0.6487 - val_acc: 0.8137 Epoch 112/300 5/5 [==============================] - 0s 67ms/step - loss: 0.4050 - acc: 0.8633 - val_loss: 0.6471 - val_acc: 0.8186 Epoch 113/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4120 - acc: 0.8522 - val_loss: 0.6375 - val_acc: 0.8137 Epoch 114/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3802 - acc: 0.8793 - val_loss: 0.6454 - val_acc: 0.8137 Epoch 115/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4073 - acc: 0.8730 - val_loss: 0.6504 - val_acc: 0.8088 Epoch 116/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3573 - acc: 0.8948 - val_loss: 0.6501 - val_acc: 0.7990 Epoch 117/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4238 - acc: 0.8611 - val_loss: 0.7339 - val_acc: 0.7843 Epoch 118/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3565 - acc: 0.8832 - val_loss: 0.7533 - val_acc: 0.7941 Epoch 119/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3863 - acc: 0.8834 - val_loss: 0.7470 - val_acc: 0.8186 Epoch 120/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3935 - acc: 0.8768 - val_loss: 0.6778 - val_acc: 0.8333 Epoch 121/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3745 - acc: 0.8862 - val_loss: 0.6741 - val_acc: 0.8137 Epoch 122/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4152 - acc: 0.8647 - val_loss: 0.6594 - val_acc: 0.8235 Epoch 123/300 5/5 [==============================] - 0s 64ms/step - loss: 0.3987 - acc: 0.8813 - val_loss: 0.6478 - val_acc: 0.8235 Epoch 124/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4005 - acc: 0.8798 - val_loss: 0.6837 - val_acc: 0.8284 Epoch 125/300 5/5 [==============================] - 0s 68ms/step - loss: 0.4366 - acc: 0.8699 - val_loss: 0.6456 - val_acc: 0.8235 Epoch 126/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3544 - acc: 0.8852 - val_loss: 0.6967 - val_acc: 0.8088 Epoch 127/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3835 - acc: 0.8676 - val_loss: 0.7279 - val_acc: 0.8088 Epoch 128/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3932 - acc: 0.8723 - val_loss: 0.7471 - val_acc: 0.8137 Epoch 129/300 5/5 [==============================] - 0s 66ms/step - loss: 0.3788 - acc: 0.8822 - val_loss: 0.7028 - val_acc: 0.8284 Epoch 130/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3546 - acc: 0.8876 - val_loss: 0.6424 - val_acc: 0.8382 Epoch 131/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4244 - acc: 0.8784 - val_loss: 0.6478 - val_acc: 0.8382 Epoch 132/300 5/5 [==============================] - 0s 66ms/step - loss: 0.4120 - acc: 0.8689 - val_loss: 0.6834 - val_acc: 0.8186 Epoch 133/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3585 - acc: 0.8872 - val_loss: 0.6802 - val_acc: 0.8186 Epoch 134/300 5/5 [==============================] - 0s 71ms/step - loss: 0.3782 - acc: 0.8788 - val_loss: 0.6936 - val_acc: 0.8235 Epoch 135/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3459 - acc: 0.8776 - val_loss: 0.6776 - val_acc: 0.8431 Epoch 136/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3176 - acc: 0.9108 - val_loss: 0.6881 - val_acc: 0.8382 Epoch 137/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3205 - acc: 0.9052 - val_loss: 0.6934 - val_acc: 0.8431 Epoch 138/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4079 - acc: 0.8782 - val_loss: 0.6830 - val_acc: 0.8431 Epoch 139/300 5/5 [==============================] - 0s 71ms/step - loss: 0.3465 - acc: 0.8973 - val_loss: 0.6876 - val_acc: 0.8431 Epoch 140/300 5/5 [==============================] - 0s 95ms/step - loss: 0.3935 - acc: 0.8766 - val_loss: 0.7166 - val_acc: 0.8382 Epoch 141/300 5/5 [==============================] - 0s 71ms/step - loss: 0.3905 - acc: 0.8868 - val_loss: 0.7320 - val_acc: 0.8284 Epoch 142/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3482 - acc: 0.8887 - val_loss: 0.7575 - val_acc: 0.8186 Epoch 143/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3567 - acc: 0.8820 - val_loss: 0.7537 - val_acc: 0.8235 Epoch 144/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3427 - acc: 0.8753 - val_loss: 0.7225 - val_acc: 0.8284 Epoch 145/300 5/5 [==============================] - 0s 72ms/step - loss: 0.3894 - acc: 0.8750 - val_loss: 0.7228 - val_acc: 0.8333 Epoch 146/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3585 - acc: 0.8938 - val_loss: 0.6870 - val_acc: 0.8284 Epoch 147/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3450 - acc: 0.8830 - val_loss: 0.6666 - val_acc: 0.8284 Epoch 148/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3174 - acc: 0.8929 - val_loss: 0.6683 - val_acc: 0.8382 Epoch 149/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3357 - acc: 0.9041 - val_loss: 0.6676 - val_acc: 0.8480 Epoch 150/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3597 - acc: 0.8792 - val_loss: 0.6913 - val_acc: 0.8235 Epoch 151/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3043 - acc: 0.9093 - val_loss: 0.7146 - val_acc: 0.8039 Epoch 152/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3935 - acc: 0.8814 - val_loss: 0.6716 - val_acc: 0.8382 Epoch 153/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3200 - acc: 0.8898 - val_loss: 0.6832 - val_acc: 0.8578 Epoch 154/300 5/5 [==============================] - 0s 71ms/step - loss: 0.3738 - acc: 0.8809 - val_loss: 0.6622 - val_acc: 0.8529 Epoch 155/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3784 - acc: 0.8777 - val_loss: 0.6510 - val_acc: 0.8431 Epoch 156/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3565 - acc: 0.8962 - val_loss: 0.6600 - val_acc: 0.8333 Epoch 157/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2935 - acc: 0.9137 - val_loss: 0.6732 - val_acc: 0.8333 Epoch 158/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3130 - acc: 0.9060 - val_loss: 0.7070 - val_acc: 0.8284 Epoch 159/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3386 - acc: 0.8937 - val_loss: 0.6865 - val_acc: 0.8480 Epoch 160/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3310 - acc: 0.9038 - val_loss: 0.7082 - val_acc: 0.8382 Epoch 161/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3232 - acc: 0.8993 - val_loss: 0.7184 - val_acc: 0.8431 Epoch 162/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3062 - acc: 0.9036 - val_loss: 0.7070 - val_acc: 0.8382 Epoch 163/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3374 - acc: 0.8962 - val_loss: 0.7187 - val_acc: 0.8284 Epoch 164/300 5/5 [==============================] - 0s 94ms/step - loss: 0.3249 - acc: 0.8977 - val_loss: 0.7197 - val_acc: 0.8382 Epoch 165/300 5/5 [==============================] - 0s 69ms/step - loss: 0.4041 - acc: 0.8764 - val_loss: 0.7195 - val_acc: 0.8431 Epoch 166/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3356 - acc: 0.9015 - val_loss: 0.7114 - val_acc: 0.8333 Epoch 167/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3006 - acc: 0.9017 - val_loss: 0.6988 - val_acc: 0.8235 Epoch 168/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3368 - acc: 0.8970 - val_loss: 0.6795 - val_acc: 0.8284 Epoch 169/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3049 - acc: 0.9124 - val_loss: 0.6590 - val_acc: 0.8333 Epoch 170/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3652 - acc: 0.8900 - val_loss: 0.6538 - val_acc: 0.8431 Epoch 171/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3153 - acc: 0.9094 - val_loss: 0.6342 - val_acc: 0.8480 Epoch 172/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2881 - acc: 0.9038 - val_loss: 0.6242 - val_acc: 0.8382 Epoch 173/300 5/5 [==============================] - 0s 66ms/step - loss: 0.3764 - acc: 0.8824 - val_loss: 0.6220 - val_acc: 0.8480 Epoch 174/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3352 - acc: 0.8958 - val_loss: 0.6305 - val_acc: 0.8578 Epoch 175/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3450 - acc: 0.9026 - val_loss: 0.6426 - val_acc: 0.8578 Epoch 176/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3471 - acc: 0.8941 - val_loss: 0.6653 - val_acc: 0.8333 Epoch 177/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3373 - acc: 0.8970 - val_loss: 0.6941 - val_acc: 0.8137 Epoch 178/300 5/5 [==============================] - 0s 69ms/step - loss: 0.2986 - acc: 0.9092 - val_loss: 0.6841 - val_acc: 0.8137 Epoch 179/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3466 - acc: 0.9038 - val_loss: 0.6704 - val_acc: 0.8284 Epoch 180/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3661 - acc: 0.8998 - val_loss: 0.6995 - val_acc: 0.8235 Epoch 181/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3163 - acc: 0.8902 - val_loss: 0.6806 - val_acc: 0.8235 Epoch 182/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3278 - acc: 0.9025 - val_loss: 0.6815 - val_acc: 0.8284 Epoch 183/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3343 - acc: 0.8960 - val_loss: 0.6704 - val_acc: 0.8333 Epoch 184/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3172 - acc: 0.8906 - val_loss: 0.6434 - val_acc: 0.8333 Epoch 185/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3679 - acc: 0.8921 - val_loss: 0.6394 - val_acc: 0.8529 Epoch 186/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3030 - acc: 0.9079 - val_loss: 0.6677 - val_acc: 0.8480 Epoch 187/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3102 - acc: 0.8908 - val_loss: 0.6456 - val_acc: 0.8529 Epoch 188/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2763 - acc: 0.9140 - val_loss: 0.6151 - val_acc: 0.8431 Epoch 189/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3298 - acc: 0.8964 - val_loss: 0.6119 - val_acc: 0.8676 Epoch 190/300 5/5 [==============================] - 0s 69ms/step - loss: 0.2928 - acc: 0.9094 - val_loss: 0.6141 - val_acc: 0.8480 Epoch 191/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3066 - acc: 0.9093 - val_loss: 0.6393 - val_acc: 0.8480 Epoch 192/300 5/5 [==============================] - 0s 94ms/step - loss: 0.2988 - acc: 0.9060 - val_loss: 0.6380 - val_acc: 0.8431 Epoch 193/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3654 - acc: 0.8800 - val_loss: 0.6102 - val_acc: 0.8578 Epoch 194/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3482 - acc: 0.8981 - val_loss: 0.6396 - val_acc: 0.8480 Epoch 195/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3029 - acc: 0.9083 - val_loss: 0.6410 - val_acc: 0.8431 Epoch 196/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3276 - acc: 0.8931 - val_loss: 0.6209 - val_acc: 0.8529 Epoch 197/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3252 - acc: 0.8989 - val_loss: 0.6153 - val_acc: 0.8578 Epoch 198/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3542 - acc: 0.8917 - val_loss: 0.6079 - val_acc: 0.8627 Epoch 199/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3191 - acc: 0.9006 - val_loss: 0.6087 - val_acc: 0.8578 Epoch 200/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3077 - acc: 0.9008 - val_loss: 0.6209 - val_acc: 0.8529 Epoch 201/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3045 - acc: 0.9076 - val_loss: 0.6609 - val_acc: 0.8333 Epoch 202/300 5/5 [==============================] - 0s 71ms/step - loss: 0.3053 - acc: 0.9058 - val_loss: 0.7324 - val_acc: 0.8284 Epoch 203/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3107 - acc: 0.8985 - val_loss: 0.7755 - val_acc: 0.8235 Epoch 204/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3047 - acc: 0.8995 - val_loss: 0.7936 - val_acc: 0.7941 Epoch 205/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3131 - acc: 0.9098 - val_loss: 0.6453 - val_acc: 0.8529 Epoch 206/300 5/5 [==============================] - 0s 71ms/step - loss: 0.3795 - acc: 0.8849 - val_loss: 0.6213 - val_acc: 0.8529 Epoch 207/300 5/5 [==============================] - 0s 70ms/step - loss: 0.2903 - acc: 0.9114 - val_loss: 0.6354 - val_acc: 0.8578 Epoch 208/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2599 - acc: 0.9164 - val_loss: 0.6390 - val_acc: 0.8676 Epoch 209/300 5/5 [==============================] - 0s 71ms/step - loss: 0.2954 - acc: 0.9041 - val_loss: 0.6376 - val_acc: 0.8775 Epoch 210/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3250 - acc: 0.9023 - val_loss: 0.6206 - val_acc: 0.8725 Epoch 211/300 5/5 [==============================] - 0s 69ms/step - loss: 0.2694 - acc: 0.9149 - val_loss: 0.6177 - val_acc: 0.8676 Epoch 212/300 5/5 [==============================] - 0s 71ms/step - loss: 0.2920 - acc: 0.9054 - val_loss: 0.6438 - val_acc: 0.8627 Epoch 213/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2861 - acc: 0.9048 - val_loss: 0.7128 - val_acc: 0.8480 Epoch 214/300 5/5 [==============================] - 0s 65ms/step - loss: 0.2916 - acc: 0.9083 - val_loss: 0.7030 - val_acc: 0.8431 Epoch 215/300 5/5 [==============================] - 0s 91ms/step - loss: 0.3288 - acc: 0.8887 - val_loss: 0.6593 - val_acc: 0.8529 Epoch 216/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3802 - acc: 0.8875 - val_loss: 0.6165 - val_acc: 0.8578 Epoch 217/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2905 - acc: 0.9175 - val_loss: 0.6141 - val_acc: 0.8725 Epoch 218/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3078 - acc: 0.9104 - val_loss: 0.6158 - val_acc: 0.8676 Epoch 219/300 5/5 [==============================] - 0s 66ms/step - loss: 0.2757 - acc: 0.9214 - val_loss: 0.6195 - val_acc: 0.8578 Epoch 220/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3159 - acc: 0.8958 - val_loss: 0.6375 - val_acc: 0.8578 Epoch 221/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3348 - acc: 0.8944 - val_loss: 0.6839 - val_acc: 0.8431 Epoch 222/300 5/5 [==============================] - 0s 70ms/step - loss: 0.3239 - acc: 0.8936 - val_loss: 0.6450 - val_acc: 0.8578 Epoch 223/300 5/5 [==============================] - 0s 73ms/step - loss: 0.2783 - acc: 0.9081 - val_loss: 0.6163 - val_acc: 0.8627 Epoch 224/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2852 - acc: 0.9165 - val_loss: 0.6495 - val_acc: 0.8431 Epoch 225/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3073 - acc: 0.8902 - val_loss: 0.6622 - val_acc: 0.8529 Epoch 226/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3127 - acc: 0.9102 - val_loss: 0.6652 - val_acc: 0.8431 Epoch 227/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3248 - acc: 0.9067 - val_loss: 0.6475 - val_acc: 0.8529 Epoch 228/300 5/5 [==============================] - 0s 69ms/step - loss: 0.3155 - acc: 0.9089 - val_loss: 0.6263 - val_acc: 0.8382 Epoch 229/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3585 - acc: 0.8898 - val_loss: 0.6308 - val_acc: 0.8578 Epoch 230/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2812 - acc: 0.9180 - val_loss: 0.6201 - val_acc: 0.8529 Epoch 231/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3070 - acc: 0.8984 - val_loss: 0.6170 - val_acc: 0.8431 Epoch 232/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3433 - acc: 0.8909 - val_loss: 0.6568 - val_acc: 0.8431 Epoch 233/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2844 - acc: 0.9085 - val_loss: 0.6571 - val_acc: 0.8529 Epoch 234/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3122 - acc: 0.9044 - val_loss: 0.6516 - val_acc: 0.8480 Epoch 235/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3047 - acc: 0.9232 - val_loss: 0.6505 - val_acc: 0.8480 Epoch 236/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2913 - acc: 0.9192 - val_loss: 0.6432 - val_acc: 0.8529 Epoch 237/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2505 - acc: 0.9322 - val_loss: 0.6462 - val_acc: 0.8627 Epoch 238/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3033 - acc: 0.9085 - val_loss: 0.6378 - val_acc: 0.8627 Epoch 239/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3418 - acc: 0.8975 - val_loss: 0.6232 - val_acc: 0.8578 Epoch 240/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3167 - acc: 0.9051 - val_loss: 0.6284 - val_acc: 0.8627 Epoch 241/300 5/5 [==============================] - 0s 69ms/step - loss: 0.2637 - acc: 0.9145 - val_loss: 0.6427 - val_acc: 0.8627 Epoch 242/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2678 - acc: 0.9227 - val_loss: 0.6492 - val_acc: 0.8578 Epoch 243/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2730 - acc: 0.9113 - val_loss: 0.6736 - val_acc: 0.8578 Epoch 244/300 5/5 [==============================] - 0s 93ms/step - loss: 0.3013 - acc: 0.9077 - val_loss: 0.7138 - val_acc: 0.8333 Epoch 245/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3151 - acc: 0.9096 - val_loss: 0.7278 - val_acc: 0.8382 Epoch 246/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3307 - acc: 0.9058 - val_loss: 0.6944 - val_acc: 0.8627 Epoch 247/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2631 - acc: 0.9236 - val_loss: 0.6789 - val_acc: 0.8529 Epoch 248/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3215 - acc: 0.9027 - val_loss: 0.6790 - val_acc: 0.8529 Epoch 249/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2968 - acc: 0.9038 - val_loss: 0.6864 - val_acc: 0.8480 Epoch 250/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2998 - acc: 0.9078 - val_loss: 0.7079 - val_acc: 0.8480 Epoch 251/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2375 - acc: 0.9197 - val_loss: 0.7252 - val_acc: 0.8529 Epoch 252/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2955 - acc: 0.9178 - val_loss: 0.7298 - val_acc: 0.8284 Epoch 253/300 5/5 [==============================] - 0s 69ms/step - loss: 0.2946 - acc: 0.9039 - val_loss: 0.7172 - val_acc: 0.8284 Epoch 254/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3051 - acc: 0.9087 - val_loss: 0.6861 - val_acc: 0.8382 Epoch 255/300 5/5 [==============================] - 0s 67ms/step - loss: 0.3563 - acc: 0.8882 - val_loss: 0.6739 - val_acc: 0.8480 Epoch 256/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3144 - acc: 0.8969 - val_loss: 0.6970 - val_acc: 0.8382 Epoch 257/300 5/5 [==============================] - 0s 68ms/step - loss: 0.3210 - acc: 0.9152 - val_loss: 0.7106 - val_acc: 0.8333 Epoch 258/300 5/5 [==============================] - 0s 67ms/step - loss: 0.2523 - acc: 0.9214 - val_loss: 0.7111 - val_acc: 0.8431 Epoch 259/300 5/5 [==============================] - 0s 68ms/step - loss: 0.2552 - acc: 0.9236 - val_loss: 0.7258 - val_acc: 0.8382 Let's plot the learning curves display_learning_curves(history) png Now we evaluate the GNN model on the test data split. The results may vary depending on the training sample, however the GNN model always outperforms the baseline model in terms of the test accuracy. x_test = test_data.paper_id.to_numpy() _, test_accuracy = gnn_model.evaluate(x=x_test, y=y_test, verbose=0) print(f\"Test accuracy: {round(test_accuracy * 100, 2)}%\") Test accuracy: 80.19% Examine the GNN model predictions Let's add the new instances as nodes to the node_features, and generate links (citations) to existing nodes. # First we add the N new_instances as nodes to the graph # by appending the new_instance to node_features. num_nodes = node_features.shape[0] new_node_features = np.concatenate([node_features, new_instances]) # Second we add the M edges (citations) from each new node to a set # of existing nodes in a particular subject new_node_indices = [i + num_nodes for i in range(num_classes)] new_citations = [] for subject_idx, group in papers.groupby(\"subject\"): subject_papers = list(group.paper_id) # Select random x papers specific subject. selected_paper_indices1 = np.random.choice(subject_papers, 5) # Select random y papers from any subject (where y < x). selected_paper_indices2 = np.random.choice(list(papers.paper_id), 2) # Merge the selected paper indices. selected_paper_indices = np.concatenate( [selected_paper_indices1, selected_paper_indices2], axis=0 ) # Create edges between a citing paper idx and the selected cited papers. citing_paper_indx = new_node_indices[subject_idx] for cited_paper_idx in selected_paper_indices: new_citations.append([citing_paper_indx, cited_paper_idx]) new_citations = np.array(new_citations).T new_edges = np.concatenate([edges, new_citations], axis=1) Now let's update the node_features and the edges in the GNN model. print(\"Original node_features shape:\", gnn_model.node_features.shape) print(\"Original edges shape:\", gnn_model.edges.shape) gnn_model.node_features = new_node_features gnn_model.edges = new_edges gnn_model.edge_weights = tf.ones(shape=new_edges.shape[1]) print(\"New node_features shape:\", gnn_model.node_features.shape) print(\"New edges shape:\", gnn_model.edges.shape) logits = gnn_model.predict(tf.convert_to_tensor(new_node_indices)) probabilities = keras.activations.softmax(tf.convert_to_tensor(logits)).numpy() display_class_probabilities(probabilities) Original node_features shape: (2708, 1433) Original edges shape: (2, 5429) New node_features shape: (2715, 1433) New edges shape: (2, 5478) Instance 1: - Case_Based: 4.35% - Genetic_Algorithms: 4.19% - Neural_Networks: 1.49% - Probabilistic_Methods: 1.68% - Reinforcement_Learning: 21.34% - Rule_Learning: 52.82% - Theory: 14.14% Instance 2: - Case_Based: 0.01% - Genetic_Algorithms: 99.88% - Neural_Networks: 0.03% - Probabilistic_Methods: 0.0% - Reinforcement_Learning: 0.07% - Rule_Learning: 0.0% - Theory: 0.01% Instance 3: - Case_Based: 0.1% - Genetic_Algorithms: 59.18% - Neural_Networks: 39.17% - Probabilistic_Methods: 0.38% - Reinforcement_Learning: 0.55% - Rule_Learning: 0.08% - Theory: 0.54% Instance 4: - Case_Based: 0.14% - Genetic_Algorithms: 10.44% - Neural_Networks: 84.1% - Probabilistic_Methods: 3.61% - Reinforcement_Learning: 0.71% - Rule_Learning: 0.16% - Theory: 0.85% Instance 5: - Case_Based: 0.27% - Genetic_Algorithms: 0.15% - Neural_Networks: 0.48% - Probabilistic_Methods: 0.23% - Reinforcement_Learning: 0.79% - Rule_Learning: 0.45% - Theory: 97.63% Instance 6: - Case_Based: 3.12% - Genetic_Algorithms: 1.35% - Neural_Networks: 19.72% - Probabilistic_Methods: 0.48% - Reinforcement_Learning: 39.56% - Rule_Learning: 28.0% - Theory: 7.77% Instance 7: - Case_Based: 1.6% - Genetic_Algorithms: 34.76% - Neural_Networks: 4.45% - Probabilistic_Methods: 9.59% - Reinforcement_Learning: 2.97% - Rule_Learning: 4.05% - Theory: 42.6% Notice that the probabilities of the expected subjects (to which several citations are added) are higher compared to the baseline model. Train a 2-layer bidirectional LSTM on the IMDB movie review sentiment classification. Setup import numpy as np from tensorflow import keras from tensorflow.keras import layers max_features = 20000 # Only consider the top 20k words maxlen = 200 # Only consider the first 200 words of each movie review Build the model # Input for variable-length sequences of integers inputs = keras.Input(shape=(None,), dtype=\"int32\") # Embed each integer in a 128-dimensional vector x = layers.Embedding(max_features, 128)(inputs) # Add 2 bidirectional LSTMs x = layers.Bidirectional(layers.LSTM(64, return_sequences=True))(x) x = layers.Bidirectional(layers.LSTM(64))(x) # Add a classifier outputs = layers.Dense(1, activation=\"sigmoid\")(x) model = keras.Model(inputs, outputs) model.summary() Model: \"model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, None)] 0 _________________________________________________________________ embedding (Embedding) (None, None, 128) 2560000 _________________________________________________________________ bidirectional (Bidirectional (None, None, 128) 98816 _________________________________________________________________ bidirectional_1 (Bidirection (None, 128) 98816 _________________________________________________________________ dense (Dense) (None, 1) 129 ================================================================= Total params: 2,757,761 Trainable params: 2,757,761 Non-trainable params: 0 _________________________________________________________________ Load the IMDB movie review sentiment data (x_train, y_train), (x_val, y_val) = keras.datasets.imdb.load_data( num_words=max_features ) print(len(x_train), \"Training sequences\") print(len(x_val), \"Validation sequences\") x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen) x_val = keras.preprocessing.sequence.pad_sequences(x_val, maxlen=maxlen) 25000 Training sequences 25000 Validation sequences Train and evaluate the model model.compile(\"adam\", \"binary_crossentropy\", metrics=[\"accuracy\"]) model.fit(x_train, y_train, batch_size=32, epochs=2, validation_data=(x_val, y_val)) Epoch 1/2 782/782 [==============================] - 220s 281ms/step - loss: 0.4117 - accuracy: 0.8083 - val_loss: 0.6497 - val_accuracy: 0.6983 Epoch 2/2 726/782 [==========================>...] - ETA: 11s - loss: 0.3170 - accuracy: 0.8683 Character-level recurrent sequence-to-sequence model. Introduction This example demonstrates how to implement a basic character-level recurrent sequence-to-sequence model. We apply it to translating short English sentences into short French sentences, character-by-character. Note that it is fairly unusual to do character-level machine translation, as word-level models are more common in this domain. Summary of the algorithm We start with input sequences from a domain (e.g. English sentences) and corresponding target sequences from another domain (e.g. French sentences). An encoder LSTM turns input sequences to 2 state vectors (we keep the last LSTM state and discard the outputs). A decoder LSTM is trained to turn the target sequences into the same sequence but offset by one timestep in the future, a training process called \"teacher forcing\" in this context. It uses as initial state the state vectors from the encoder. Effectively, the decoder learns to generate targets[t+1...] given targets[...t], conditioned on the input sequence. In inference mode, when we want to decode unknown input sequences, we: - Encode the input sequence into state vectors - Start with a target sequence of size 1 (just the start-of-sequence character) - Feed the state vectors and 1-char target sequence to the decoder to produce predictions for the next character - Sample the next character using these predictions (we simply use argmax). - Append the sampled character to the target sequence - Repeat until we generate the end-of-sequence character or we hit the character limit. Setup import numpy as np import tensorflow as tf from tensorflow import keras Download the data !!curl -O http://www.manythings.org/anki/fra-eng.zip !!unzip fra-eng.zip ['Archive: fra-eng.zip', ' inflating: _about.txt ', ' inflating: fra.txt '] Configuration batch_size = 64 # Batch size for training. epochs = 100 # Number of epochs to train for. latent_dim = 256 # Latent dimensionality of the encoding space. num_samples = 10000 # Number of samples to train on. # Path to the data txt file on disk. data_path = \"fra.txt\" Prepare the data # Vectorize the data. input_texts = [] target_texts = [] input_characters = set() target_characters = set() with open(data_path, \"r\", encoding=\"utf-8\") as f: lines = f.read().split(\"\n\") for line in lines[: min(num_samples, len(lines) - 1)]: input_text, target_text, _ = line.split(\"\t\") # We use \"tab\" as the \"start sequence\" character # for the targets, and \"\n\" as \"end sequence\" character. target_text = \"\t\" + target_text + \"\n\" input_texts.append(input_text) target_texts.append(target_text) for char in input_text: if char not in input_characters: input_characters.add(char) for char in target_text: if char not in target_characters: target_characters.add(char) input_characters = sorted(list(input_characters)) target_characters = sorted(list(target_characters)) num_encoder_tokens = len(input_characters) num_decoder_tokens = len(target_characters) max_encoder_seq_length = max([len(txt) for txt in input_texts]) max_decoder_seq_length = max([len(txt) for txt in target_texts]) print(\"Number of samples:\", len(input_texts)) print(\"Number of unique input tokens:\", num_encoder_tokens) print(\"Number of unique output tokens:\", num_decoder_tokens) print(\"Max sequence length for inputs:\", max_encoder_seq_length) print(\"Max sequence length for outputs:\", max_decoder_seq_length) input_token_index = dict([(char, i) for i, char in enumerate(input_characters)]) target_token_index = dict([(char, i) for i, char in enumerate(target_characters)]) encoder_input_data = np.zeros( (len(input_texts), max_encoder_seq_length, num_encoder_tokens), dtype=\"float32\" ) decoder_input_data = np.zeros( (len(input_texts), max_decoder_seq_length, num_decoder_tokens), dtype=\"float32\" ) decoder_target_data = np.zeros( (len(input_texts), max_decoder_seq_length, num_decoder_tokens), dtype=\"float32\" ) for i, (input_text, target_text) in enumerate(zip(input_texts, target_texts)): for t, char in enumerate(input_text): encoder_input_data[i, t, input_token_index[char]] = 1.0 encoder_input_data[i, t + 1 :, input_token_index[\" \"]] = 1.0 for t, char in enumerate(target_text): # decoder_target_data is ahead of decoder_input_data by one timestep decoder_input_data[i, t, target_token_index[char]] = 1.0 if t > 0: # decoder_target_data will be ahead by one timestep # and will not include the start character. decoder_target_data[i, t - 1, target_token_index[char]] = 1.0 decoder_input_data[i, t + 1 :, target_token_index[\" \"]] = 1.0 decoder_target_data[i, t:, target_token_index[\" \"]] = 1.0 Number of samples: 10000 Number of unique input tokens: 71 Number of unique output tokens: 93 Max sequence length for inputs: 16 Max sequence length for outputs: 59 Build the model # Define an input sequence and process it. encoder_inputs = keras.Input(shape=(None, num_encoder_tokens)) encoder = keras.layers.LSTM(latent_dim, return_state=True) encoder_outputs, state_h, state_c = encoder(encoder_inputs) # We discard `encoder_outputs` and only keep the states. encoder_states = [state_h, state_c] # Set up the decoder, using `encoder_states` as initial state. decoder_inputs = keras.Input(shape=(None, num_decoder_tokens)) # We set up our decoder to return full output sequences, # and to return internal states as well. We don't use the # return states in the training model, but we will use them in inference. decoder_lstm = keras.layers.LSTM(latent_dim, return_sequences=True, return_state=True) decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=encoder_states) decoder_dense = keras.layers.Dense(num_decoder_tokens, activation=\"softmax\") decoder_outputs = decoder_dense(decoder_outputs) # Define the model that will turn # `encoder_input_data` & `decoder_input_data` into `decoder_target_data` model = keras.Model([encoder_inputs, decoder_inputs], decoder_outputs) Train the model model.compile( optimizer=\"rmsprop\", loss=\"categorical_crossentropy\", metrics=[\"accuracy\"] ) model.fit( [encoder_input_data, decoder_input_data], decoder_target_data, batch_size=batch_size, epochs=epochs, validation_split=0.2, ) # Save model model.save(\"s2s\") Epoch 1/100 125/125 [==============================] - 2s 16ms/step - loss: 1.1806 - accuracy: 0.7246 - val_loss: 1.0825 - val_accuracy: 0.6995 Epoch 2/100 125/125 [==============================] - 1s 11ms/step - loss: 0.8599 - accuracy: 0.7671 - val_loss: 0.8524 - val_accuracy: 0.7646 Epoch 3/100 125/125 [==============================] - 1s 11ms/step - loss: 0.6867 - accuracy: 0.8069 - val_loss: 0.7129 - val_accuracy: 0.7928 Epoch 4/100 125/125 [==============================] - 1s 11ms/step - loss: 0.5982 - accuracy: 0.8262 - val_loss: 0.6547 - val_accuracy: 0.8111 Epoch 5/100 125/125 [==============================] - 1s 11ms/step - loss: 0.5490 - accuracy: 0.8398 - val_loss: 0.6407 - val_accuracy: 0.8114 Epoch 6/100 125/125 [==============================] - 1s 11ms/step - loss: 0.5140 - accuracy: 0.8489 - val_loss: 0.5834 - val_accuracy: 0.8288 Epoch 7/100 125/125 [==============================] - 1s 11ms/step - loss: 0.4854 - accuracy: 0.8569 - val_loss: 0.5577 - val_accuracy: 0.8357 Epoch 8/100 125/125 [==============================] - 1s 11ms/step - loss: 0.4613 - accuracy: 0.8632 - val_loss: 0.5384 - val_accuracy: 0.8407 Epoch 9/100 125/125 [==============================] - 1s 11ms/step - loss: 0.4405 - accuracy: 0.8691 - val_loss: 0.5255 - val_accuracy: 0.8435 Epoch 10/100 125/125 [==============================] - 1s 11ms/step - loss: 0.4219 - accuracy: 0.8743 - val_loss: 0.5049 - val_accuracy: 0.8497 Epoch 11/100 125/125 [==============================] - 1s 11ms/step - loss: 0.4042 - accuracy: 0.8791 - val_loss: 0.4986 - val_accuracy: 0.8522 Epoch 12/100 125/125 [==============================] - 1s 11ms/step - loss: 0.3888 - accuracy: 0.8836 - val_loss: 0.4854 - val_accuracy: 0.8552 Epoch 13/100 125/125 [==============================] - 1s 11ms/step - loss: 0.3735 - accuracy: 0.8883 - val_loss: 0.4754 - val_accuracy: 0.8586 Epoch 14/100 125/125 [==============================] - 1s 11ms/step - loss: 0.3595 - accuracy: 0.8915 - val_loss: 0.4753 - val_accuracy: 0.8589 Epoch 15/100 125/125 [==============================] - 1s 11ms/step - loss: 0.3467 - accuracy: 0.8956 - val_loss: 0.4611 - val_accuracy: 0.8634 Epoch 16/100 125/125 [==============================] - 1s 11ms/step - loss: 0.3346 - accuracy: 0.8991 - val_loss: 0.4535 - val_accuracy: 0.8658 Epoch 17/100 125/125 [==============================] - 1s 11ms/step - loss: 0.3231 - accuracy: 0.9025 - val_loss: 0.4504 - val_accuracy: 0.8665 Epoch 18/100 125/125 [==============================] - 1s 11ms/step - loss: 0.3120 - accuracy: 0.9059 - val_loss: 0.4442 - val_accuracy: 0.8699 Epoch 19/100 125/125 [==============================] - 1s 10ms/step - loss: 0.3015 - accuracy: 0.9088 - val_loss: 0.4439 - val_accuracy: 0.8692 Epoch 20/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2917 - accuracy: 0.9118 - val_loss: 0.4415 - val_accuracy: 0.8712 Epoch 21/100 125/125 [==============================] - 1s 10ms/step - loss: 0.2821 - accuracy: 0.9147 - val_loss: 0.4372 - val_accuracy: 0.8722 Epoch 22/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2731 - accuracy: 0.9174 - val_loss: 0.4424 - val_accuracy: 0.8713 Epoch 23/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2642 - accuracy: 0.9201 - val_loss: 0.4371 - val_accuracy: 0.8725 Epoch 24/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2561 - accuracy: 0.9226 - val_loss: 0.4400 - val_accuracy: 0.8728 Epoch 25/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2481 - accuracy: 0.9245 - val_loss: 0.4358 - val_accuracy: 0.8757 Epoch 26/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2404 - accuracy: 0.9270 - val_loss: 0.4407 - val_accuracy: 0.8746 Epoch 27/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2332 - accuracy: 0.9294 - val_loss: 0.4462 - val_accuracy: 0.8736 Epoch 28/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2263 - accuracy: 0.9310 - val_loss: 0.4436 - val_accuracy: 0.8736 Epoch 29/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2194 - accuracy: 0.9328 - val_loss: 0.4411 - val_accuracy: 0.8755 Epoch 30/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2126 - accuracy: 0.9351 - val_loss: 0.4457 - val_accuracy: 0.8755 Epoch 31/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2069 - accuracy: 0.9370 - val_loss: 0.4498 - val_accuracy: 0.8752 Epoch 32/100 125/125 [==============================] - 1s 11ms/step - loss: 0.2010 - accuracy: 0.9388 - val_loss: 0.4518 - val_accuracy: 0.8755 Epoch 33/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1953 - accuracy: 0.9404 - val_loss: 0.4545 - val_accuracy: 0.8758 Epoch 34/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1897 - accuracy: 0.9423 - val_loss: 0.4547 - val_accuracy: 0.8769 Epoch 35/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1846 - accuracy: 0.9435 - val_loss: 0.4582 - val_accuracy: 0.8763 Epoch 36/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1794 - accuracy: 0.9451 - val_loss: 0.4653 - val_accuracy: 0.8755 Epoch 37/100 125/125 [==============================] - 1s 10ms/step - loss: 0.1747 - accuracy: 0.9464 - val_loss: 0.4633 - val_accuracy: 0.8768 Epoch 38/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1700 - accuracy: 0.9479 - val_loss: 0.4665 - val_accuracy: 0.8772 Epoch 39/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1657 - accuracy: 0.9493 - val_loss: 0.4725 - val_accuracy: 0.8755 Epoch 40/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1612 - accuracy: 0.9504 - val_loss: 0.4799 - val_accuracy: 0.8752 Epoch 41/100 125/125 [==============================] - 1s 10ms/step - loss: 0.1576 - accuracy: 0.9516 - val_loss: 0.4777 - val_accuracy: 0.8760 Epoch 42/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1531 - accuracy: 0.9530 - val_loss: 0.4842 - val_accuracy: 0.8761 Epoch 43/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1495 - accuracy: 0.9542 - val_loss: 0.4879 - val_accuracy: 0.8761 Epoch 44/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1456 - accuracy: 0.9552 - val_loss: 0.4933 - val_accuracy: 0.8757 Epoch 45/100 125/125 [==============================] - 1s 10ms/step - loss: 0.1419 - accuracy: 0.9562 - val_loss: 0.4988 - val_accuracy: 0.8753 Epoch 46/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1385 - accuracy: 0.9574 - val_loss: 0.5012 - val_accuracy: 0.8758 Epoch 47/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1356 - accuracy: 0.9581 - val_loss: 0.5040 - val_accuracy: 0.8763 Epoch 48/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1325 - accuracy: 0.9591 - val_loss: 0.5114 - val_accuracy: 0.8761 Epoch 49/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1291 - accuracy: 0.9601 - val_loss: 0.5151 - val_accuracy: 0.8764 Epoch 50/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1263 - accuracy: 0.9607 - val_loss: 0.5214 - val_accuracy: 0.8761 Epoch 51/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1232 - accuracy: 0.9621 - val_loss: 0.5210 - val_accuracy: 0.8759 Epoch 52/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1205 - accuracy: 0.9626 - val_loss: 0.5232 - val_accuracy: 0.8761 Epoch 53/100 125/125 [==============================] - 1s 10ms/step - loss: 0.1177 - accuracy: 0.9633 - val_loss: 0.5329 - val_accuracy: 0.8754 Epoch 54/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1152 - accuracy: 0.9644 - val_loss: 0.5317 - val_accuracy: 0.8753 Epoch 55/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1132 - accuracy: 0.9648 - val_loss: 0.5418 - val_accuracy: 0.8748 Epoch 56/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1102 - accuracy: 0.9658 - val_loss: 0.5456 - val_accuracy: 0.8745 Epoch 57/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1083 - accuracy: 0.9663 - val_loss: 0.5438 - val_accuracy: 0.8753 Epoch 58/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1058 - accuracy: 0.9669 - val_loss: 0.5519 - val_accuracy: 0.8753 Epoch 59/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1035 - accuracy: 0.9675 - val_loss: 0.5543 - val_accuracy: 0.8753 Epoch 60/100 125/125 [==============================] - 1s 11ms/step - loss: 0.1017 - accuracy: 0.9679 - val_loss: 0.5619 - val_accuracy: 0.8756 Epoch 61/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0993 - accuracy: 0.9686 - val_loss: 0.5680 - val_accuracy: 0.8751 Epoch 62/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0975 - accuracy: 0.9690 - val_loss: 0.5768 - val_accuracy: 0.8737 Epoch 63/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0954 - accuracy: 0.9697 - val_loss: 0.5800 - val_accuracy: 0.8733 Epoch 64/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0936 - accuracy: 0.9700 - val_loss: 0.5782 - val_accuracy: 0.8744 Epoch 65/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0918 - accuracy: 0.9709 - val_loss: 0.5832 - val_accuracy: 0.8743 Epoch 66/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0897 - accuracy: 0.9714 - val_loss: 0.5863 - val_accuracy: 0.8744 Epoch 67/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0880 - accuracy: 0.9718 - val_loss: 0.5912 - val_accuracy: 0.8742 Epoch 68/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0863 - accuracy: 0.9722 - val_loss: 0.5972 - val_accuracy: 0.8741 Epoch 69/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0850 - accuracy: 0.9727 - val_loss: 0.5969 - val_accuracy: 0.8743 Epoch 70/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0832 - accuracy: 0.9732 - val_loss: 0.6046 - val_accuracy: 0.8736 Epoch 71/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0815 - accuracy: 0.9738 - val_loss: 0.6037 - val_accuracy: 0.8746 Epoch 72/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0799 - accuracy: 0.9741 - val_loss: 0.6092 - val_accuracy: 0.8744 Epoch 73/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0785 - accuracy: 0.9746 - val_loss: 0.6118 - val_accuracy: 0.8750 Epoch 74/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0769 - accuracy: 0.9751 - val_loss: 0.6150 - val_accuracy: 0.8737 Epoch 75/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0753 - accuracy: 0.9754 - val_loss: 0.6196 - val_accuracy: 0.8736 Epoch 76/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0742 - accuracy: 0.9759 - val_loss: 0.6237 - val_accuracy: 0.8738 Epoch 77/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0731 - accuracy: 0.9760 - val_loss: 0.6310 - val_accuracy: 0.8731 Epoch 78/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0719 - accuracy: 0.9765 - val_loss: 0.6335 - val_accuracy: 0.8746 Epoch 79/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0702 - accuracy: 0.9770 - val_loss: 0.6366 - val_accuracy: 0.8744 Epoch 80/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0692 - accuracy: 0.9773 - val_loss: 0.6368 - val_accuracy: 0.8745 Epoch 81/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0678 - accuracy: 0.9777 - val_loss: 0.6472 - val_accuracy: 0.8735 Epoch 82/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0669 - accuracy: 0.9778 - val_loss: 0.6474 - val_accuracy: 0.8735 Epoch 83/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0653 - accuracy: 0.9783 - val_loss: 0.6466 - val_accuracy: 0.8745 Epoch 84/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0645 - accuracy: 0.9787 - val_loss: 0.6576 - val_accuracy: 0.8733 Epoch 85/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0633 - accuracy: 0.9790 - val_loss: 0.6539 - val_accuracy: 0.8742 Epoch 86/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0626 - accuracy: 0.9792 - val_loss: 0.6609 - val_accuracy: 0.8738 Epoch 87/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0614 - accuracy: 0.9794 - val_loss: 0.6641 - val_accuracy: 0.8739 Epoch 88/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0602 - accuracy: 0.9799 - val_loss: 0.6677 - val_accuracy: 0.8739 Epoch 89/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0594 - accuracy: 0.9801 - val_loss: 0.6659 - val_accuracy: 0.8731 Epoch 90/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0581 - accuracy: 0.9803 - val_loss: 0.6744 - val_accuracy: 0.8740 Epoch 91/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0575 - accuracy: 0.9806 - val_loss: 0.6722 - val_accuracy: 0.8737 Epoch 92/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0568 - accuracy: 0.9808 - val_loss: 0.6778 - val_accuracy: 0.8737 Epoch 93/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0557 - accuracy: 0.9814 - val_loss: 0.6837 - val_accuracy: 0.8733 Epoch 94/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0548 - accuracy: 0.9814 - val_loss: 0.6906 - val_accuracy: 0.8732 Epoch 95/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0543 - accuracy: 0.9816 - val_loss: 0.6913 - val_accuracy: 0.8733 Epoch 96/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0536 - accuracy: 0.9816 - val_loss: 0.6955 - val_accuracy: 0.8723 Epoch 97/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0531 - accuracy: 0.9817 - val_loss: 0.7001 - val_accuracy: 0.8724 Epoch 98/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0521 - accuracy: 0.9821 - val_loss: 0.7017 - val_accuracy: 0.8738 Epoch 99/100 125/125 [==============================] - 1s 10ms/step - loss: 0.0512 - accuracy: 0.9822 - val_loss: 0.7069 - val_accuracy: 0.8731 Epoch 100/100 125/125 [==============================] - 1s 11ms/step - loss: 0.0506 - accuracy: 0.9826 - val_loss: 0.7050 - val_accuracy: 0.8726 WARNING:tensorflow:From /usr/local/lib/python3.7/site-packages/tensorflow/python/training/tracking/tracking.py:105: Network.state_updates (from tensorflow.python.keras.engine.network) is deprecated and will be removed in a future version. Instructions for updating: This property should not be used in TensorFlow 2.0, as updates are applied automatically. INFO:tensorflow:Assets written to: s2s/assets Run inference (sampling) encode input and retrieve initial decoder state run one step of decoder with this initial state and a \"start of sequence\" token as target. Output will be the next target token. Repeat with the current target token and current states # Define sampling models # Restore the model and construct the encoder and decoder. model = keras.models.load_model(\"s2s\") encoder_inputs = model.input[0] # input_1 encoder_outputs, state_h_enc, state_c_enc = model.layers[2].output # lstm_1 encoder_states = [state_h_enc, state_c_enc] encoder_model = keras.Model(encoder_inputs, encoder_states) decoder_inputs = model.input[1] # input_2 decoder_state_input_h = keras.Input(shape=(latent_dim,)) decoder_state_input_c = keras.Input(shape=(latent_dim,)) decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c] decoder_lstm = model.layers[3] decoder_outputs, state_h_dec, state_c_dec = decoder_lstm( decoder_inputs, initial_state=decoder_states_inputs ) decoder_states = [state_h_dec, state_c_dec] decoder_dense = model.layers[4] decoder_outputs = decoder_dense(decoder_outputs) decoder_model = keras.Model( [decoder_inputs] + decoder_states_inputs, [decoder_outputs] + decoder_states ) # Reverse-lookup token index to decode sequences back to # something readable. reverse_input_char_index = dict((i, char) for char, i in input_token_index.items()) reverse_target_char_index = dict((i, char) for char, i in target_token_index.items()) def decode_sequence(input_seq): # Encode the input as state vectors. states_value = encoder_model.predict(input_seq) # Generate empty target sequence of length 1. target_seq = np.zeros((1, 1, num_decoder_tokens)) # Populate the first character of target sequence with the start character. target_seq[0, 0, target_token_index[\"\t\"]] = 1.0 # Sampling loop for a batch of sequences # (to simplify, here we assume a batch of size 1). stop_condition = False decoded_sentence = \"\" while not stop_condition: output_tokens, h, c = decoder_model.predict([target_seq] + states_value) # Sample a token sampled_token_index = np.argmax(output_tokens[0, -1, :]) sampled_char = reverse_target_char_index[sampled_token_index] decoded_sentence += sampled_char # Exit condition: either hit max length # or find stop character. if sampled_char == \"\n\" or len(decoded_sentence) > max_decoder_seq_length: stop_condition = True # Update the target sequence (of length 1). target_seq = np.zeros((1, 1, num_decoder_tokens)) target_seq[0, 0, sampled_token_index] = 1.0 # Update states states_value = [h, c] return decoded_sentence You can now generate decoded sentences as such: for seq_index in range(20): # Take one sequence (part of the training set) # for trying out decoding. input_seq = encoder_input_data[seq_index : seq_index + 1] decoded_sentence = decode_sequence(input_seq) print(\"-\") print(\"Input sentence:\", input_texts[seq_index]) print(\"Decoded sentence:\", decoded_sentence) - Input sentence: Go. Decoded sentence: Va ! - Input sentence: Hi. Decoded sentence: Salut ! - Input sentence: Hi. Decoded sentence: Salut ! - Input sentence: Run! Decoded sentence: Cours ! - Input sentence: Run! Decoded sentence: Cours ! - Input sentence: Who? Decoded sentence: Qui ? - Input sentence: Wow! Decoded sentence: Ça alors ! - Input sentence: Fire! Decoded sentence: Au feu ! - Input sentence: Help! Decoded sentence: À l'aide ! - Input sentence: Jump. Decoded sentence: Saute. - Input sentence: Stop! Decoded sentence: Stop ! - Input sentence: Stop! Decoded sentence: Stop ! - Input sentence: Stop! Decoded sentence: Stop ! - Input sentence: Wait! Decoded sentence: Attendez ! - Input sentence: Wait! Decoded sentence: Attendez ! - Input sentence: Go on. Decoded sentence: Poursuis. - Input sentence: Go on. Decoded sentence: Poursuis. - Input sentence: Go on. Decoded sentence: Poursuis. - Input sentence: Hello! Decoded sentence: Salut ! - Input sentence: Hello! Decoded sentence: Salut ! Implement a Masked Language Model (MLM) with BERT and fine-tune it on the IMDB Reviews dataset. Introduction Masked Language Modeling is a fill-in-the-blank task, where a model uses the context words surrounding a mask token to try to predict what the masked word should be. For an input that contains one or more mask tokens, the model will generate the most likely substitution for each. Example: Input: \"I have watched this [MASK] and it was awesome.\" Output: \"I have watched this movie and it was awesome.\" Masked language modeling is a great way to train a language model in a self-supervised setting (without human-annotated labels). Such a model can then be fine-tuned to accomplish various supervised NLP tasks. This example teaches you how to build a BERT model from scratch, train it with the masked language modeling task, and then fine-tune this model on a sentiment classification task. We will use the Keras TextVectorization and MultiHeadAttention layers to create a BERT Transformer-Encoder network architecture. Note: This example should be run with tf-nightly. Setup Install tf-nightly via pip install tf-nightly. import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.layers import TextVectorization from dataclasses import dataclass import pandas as pd import numpy as np import glob import re from pprint import pprint Set-up Configuration @dataclass class Config: MAX_LEN = 256 BATCH_SIZE = 32 LR = 0.001 VOCAB_SIZE = 30000 EMBED_DIM = 128 NUM_HEAD = 8 # used in bert model FF_DIM = 128 # used in bert model NUM_LAYERS = 1 config = Config() Load the data We will first download the IMDB data and load into a Pandas dataframe. !curl -O https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz !tar -xf aclImdb_v1.tar.gz def get_text_list_from_files(files): text_list = [] for name in files: with open(name) as f: for line in f: text_list.append(line) return text_list def get_data_from_text_files(folder_name): pos_files = glob.glob(\"aclImdb/\" + folder_name + \"/pos/*.txt\") pos_texts = get_text_list_from_files(pos_files) neg_files = glob.glob(\"aclImdb/\" + folder_name + \"/neg/*.txt\") neg_texts = get_text_list_from_files(neg_files) df = pd.DataFrame( { \"review\": pos_texts + neg_texts, \"sentiment\": [0] * len(pos_texts) + [1] * len(neg_texts), } ) df = df.sample(len(df)).reset_index(drop=True) return df train_df = get_data_from_text_files(\"train\") test_df = get_data_from_text_files(\"test\") all_data = train_df.append(test_df) % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 80.2M 100 80.2M 0 0 45.3M 0 0:00:01 0:00:01 --:--:-- 45.3M Dataset preparation We will use the TextVectorization layer to vectorize the text into integer token ids. It transforms a batch of strings into either a sequence of token indices (one sample = 1D array of integer token indices, in order) or a dense representation (one sample = 1D array of float values encoding an unordered set of tokens). Below, we define 3 preprocessing functions. The get_vectorize_layer function builds the TextVectorization layer. The encode function encodes raw text into integer token ids. The get_masked_input_and_labels function will mask input token ids. It masks 15% of all input tokens in each sequence at random. def custom_standardization(input_data): lowercase = tf.strings.lower(input_data) stripped_html = tf.strings.regex_replace(lowercase, \"
\", \" \") return tf.strings.regex_replace( stripped_html, \"[%s]\" % re.escape(\"!#$%&'()*+,-./:;<=>?@\^_`{|}~\"), \"\" ) def get_vectorize_layer(texts, vocab_size, max_seq, special_tokens=[\"[MASK]\"]): \"\"\"Build Text vectorization layer Args: texts (list): List of string i.e input texts vocab_size (int): vocab size max_seq (int): Maximum sequence lenght. special_tokens (list, optional): List of special tokens. Defaults to ['[MASK]']. Returns: layers.Layer: Return TextVectorization Keras Layer \"\"\" vectorize_layer = TextVectorization( max_tokens=vocab_size, output_mode=\"int\", standardize=custom_standardization, output_sequence_length=max_seq, ) vectorize_layer.adapt(texts) # Insert mask token in vocabulary vocab = vectorize_layer.get_vocabulary() vocab = vocab[2 : vocab_size - len(special_tokens)] + [\"[mask]\"] vectorize_layer.set_vocabulary(vocab) return vectorize_layer vectorize_layer = get_vectorize_layer( all_data.review.values.tolist(), config.VOCAB_SIZE, config.MAX_LEN, special_tokens=[\"[mask]\"], ) # Get mask token id for masked language model mask_token_id = vectorize_layer([\"[mask]\"]).numpy()[0][0] def encode(texts): encoded_texts = vectorize_layer(texts) return encoded_texts.numpy() def get_masked_input_and_labels(encoded_texts): # 15% BERT masking inp_mask = np.random.rand(*encoded_texts.shape) < 0.15 # Do not mask special tokens inp_mask[encoded_texts <= 2] = False # Set targets to -1 by default, it means ignore labels = -1 * np.ones(encoded_texts.shape, dtype=int) # Set labels for masked tokens labels[inp_mask] = encoded_texts[inp_mask] # Prepare input encoded_texts_masked = np.copy(encoded_texts) # Set input to [MASK] which is the last token for the 90% of tokens # This means leaving 10% unchanged inp_mask_2mask = inp_mask & (np.random.rand(*encoded_texts.shape) < 0.90) encoded_texts_masked[ inp_mask_2mask ] = mask_token_id # mask token is the last in the dict # Set 10% to a random token inp_mask_2random = inp_mask_2mask & (np.random.rand(*encoded_texts.shape) < 1 / 9) encoded_texts_masked[inp_mask_2random] = np.random.randint( 3, mask_token_id, inp_mask_2random.sum() ) # Prepare sample_weights to pass to .fit() method sample_weights = np.ones(labels.shape) sample_weights[labels == -1] = 0 # y_labels would be same as encoded_texts i.e input tokens y_labels = np.copy(encoded_texts) return encoded_texts_masked, y_labels, sample_weights # We have 25000 examples for training x_train = encode(train_df.review.values) # encode reviews with vectorizer y_train = train_df.sentiment.values train_classifier_ds = ( tf.data.Dataset.from_tensor_slices((x_train, y_train)) .shuffle(1000) .batch(config.BATCH_SIZE) ) # We have 25000 examples for testing x_test = encode(test_df.review.values) y_test = test_df.sentiment.values test_classifier_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch( config.BATCH_SIZE ) # Build dataset for end to end model input (will be used at the end) test_raw_classifier_ds = tf.data.Dataset.from_tensor_slices( (test_df.review.values, y_test) ).batch(config.BATCH_SIZE) # Prepare data for masked language model x_all_review = encode(all_data.review.values) x_masked_train, y_masked_labels, sample_weights = get_masked_input_and_labels( x_all_review ) mlm_ds = tf.data.Dataset.from_tensor_slices( (x_masked_train, y_masked_labels, sample_weights) ) mlm_ds = mlm_ds.shuffle(1000).batch(config.BATCH_SIZE) Create BERT model (Pretraining Model) for masked language modeling We will create a BERT-like pretraining model architecture using the MultiHeadAttention layer. It will take token ids as inputs (including masked tokens) and it will predict the correct ids for the masked input tokens. def bert_module(query, key, value, i): # Multi headed self-attention attention_output = layers.MultiHeadAttention( num_heads=config.NUM_HEAD, key_dim=config.EMBED_DIM // config.NUM_HEAD, name=\"encoder_{}/multiheadattention\".format(i), )(query, key, value) attention_output = layers.Dropout(0.1, name=\"encoder_{}/att_dropout\".format(i))( attention_output ) attention_output = layers.LayerNormalization( epsilon=1e-6, name=\"encoder_{}/att_layernormalization\".format(i) )(query + attention_output) # Feed-forward layer ffn = keras.Sequential( [ layers.Dense(config.FF_DIM, activation=\"relu\"), layers.Dense(config.EMBED_DIM), ], name=\"encoder_{}/ffn\".format(i), ) ffn_output = ffn(attention_output) ffn_output = layers.Dropout(0.1, name=\"encoder_{}/ffn_dropout\".format(i))( ffn_output ) sequence_output = layers.LayerNormalization( epsilon=1e-6, name=\"encoder_{}/ffn_layernormalization\".format(i) )(attention_output + ffn_output) return sequence_output def get_pos_encoding_matrix(max_len, d_emb): pos_enc = np.array( [ [pos / np.power(10000, 2 * (j // 2) / d_emb) for j in range(d_emb)] if pos != 0 else np.zeros(d_emb) for pos in range(max_len) ] ) pos_enc[1:, 0::2] = np.sin(pos_enc[1:, 0::2]) # dim 2i pos_enc[1:, 1::2] = np.cos(pos_enc[1:, 1::2]) # dim 2i+1 return pos_enc loss_fn = keras.losses.SparseCategoricalCrossentropy( reduction=tf.keras.losses.Reduction.NONE ) loss_tracker = tf.keras.metrics.Mean(name=\"loss\") class MaskedLanguageModel(tf.keras.Model): def train_step(self, inputs): if len(inputs) == 3: features, labels, sample_weight = inputs else: features, labels = inputs sample_weight = None with tf.GradientTape() as tape: predictions = self(features, training=True) loss = loss_fn(labels, predictions, sample_weight=sample_weight) # Compute gradients trainable_vars = self.trainable_variables gradients = tape.gradient(loss, trainable_vars) # Update weights self.optimizer.apply_gradients(zip(gradients, trainable_vars)) # Compute our own metrics loss_tracker.update_state(loss, sample_weight=sample_weight) # Return a dict mapping metric names to current value return {\"loss\": loss_tracker.result()} @property def metrics(self): # We list our `Metric` objects here so that `reset_states()` can be # called automatically at the start of each epoch # or at the start of `evaluate()`. # If you don't implement this property, you have to call # `reset_states()` yourself at the time of your choosing. return [loss_tracker] def create_masked_language_bert_model(): inputs = layers.Input((config.MAX_LEN,), dtype=tf.int64) word_embeddings = layers.Embedding( config.VOCAB_SIZE, config.EMBED_DIM, name=\"word_embedding\" )(inputs) position_embeddings = layers.Embedding( input_dim=config.MAX_LEN, output_dim=config.EMBED_DIM, weights=[get_pos_encoding_matrix(config.MAX_LEN, config.EMBED_DIM)], name=\"position_embedding\", )(tf.range(start=0, limit=config.MAX_LEN, delta=1)) embeddings = word_embeddings + position_embeddings encoder_output = embeddings for i in range(config.NUM_LAYERS): encoder_output = bert_module(encoder_output, encoder_output, encoder_output, i) mlm_output = layers.Dense(config.VOCAB_SIZE, name=\"mlm_cls\", activation=\"softmax\")( encoder_output ) mlm_model = MaskedLanguageModel(inputs, mlm_output, name=\"masked_bert_model\") optimizer = keras.optimizers.Adam(learning_rate=config.LR) mlm_model.compile(optimizer=optimizer) return mlm_model id2token = dict(enumerate(vectorize_layer.get_vocabulary())) token2id = {y: x for x, y in id2token.items()} class MaskedTextGenerator(keras.callbacks.Callback): def __init__(self, sample_tokens, top_k=5): self.sample_tokens = sample_tokens self.k = top_k def decode(self, tokens): return \" \".join([id2token[t] for t in tokens if t != 0]) def convert_ids_to_tokens(self, id): return id2token[id] def on_epoch_end(self, epoch, logs=None): prediction = self.model.predict(self.sample_tokens) masked_index = np.where(self.sample_tokens == mask_token_id) masked_index = masked_index[1] mask_prediction = prediction[0][masked_index] top_indices = mask_prediction[0].argsort()[-self.k :][::-1] values = mask_prediction[0][top_indices] for i in range(len(top_indices)): p = top_indices[i] v = values[i] tokens = np.copy(sample_tokens[0]) tokens[masked_index[0]] = p result = { \"input_text\": self.decode(sample_tokens[0].numpy()), \"prediction\": self.decode(tokens), \"probability\": v, \"predicted mask token\": self.convert_ids_to_tokens(p), } pprint(result) sample_tokens = vectorize_layer([\"I have watched this [mask] and it was awesome\"]) generator_callback = MaskedTextGenerator(sample_tokens.numpy()) bert_masked_model = create_masked_language_bert_model() bert_masked_model.summary() Model: \"masked_bert_model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 256)] 0 __________________________________________________________________________________________________ word_embedding (Embedding) (None, 256, 128) 3840000 input_1[0][0] __________________________________________________________________________________________________ tf.__operators__.add (TFOpLambd (None, 256, 128) 0 word_embedding[0][0] __________________________________________________________________________________________________ encoder_0/multiheadattention (M (None, 256, 128) 66048 tf.__operators__.add[0][0] tf.__operators__.add[0][0] tf.__operators__.add[0][0] __________________________________________________________________________________________________ encoder_0/att_dropout (Dropout) (None, 256, 128) 0 encoder_0/multiheadattention[0][0 __________________________________________________________________________________________________ tf.__operators__.add_1 (TFOpLam (None, 256, 128) 0 tf.__operators__.add[0][0] encoder_0/att_dropout[0][0] __________________________________________________________________________________________________ encoder_0/att_layernormalizatio (None, 256, 128) 256 tf.__operators__.add_1[0][0] __________________________________________________________________________________________________ encoder_0/ffn (Sequential) (None, 256, 128) 33024 encoder_0/att_layernormalization[ __________________________________________________________________________________________________ encoder_0/ffn_dropout (Dropout) (None, 256, 128) 0 encoder_0/ffn[0][0] __________________________________________________________________________________________________ tf.__operators__.add_2 (TFOpLam (None, 256, 128) 0 encoder_0/att_layernormalization[ encoder_0/ffn_dropout[0][0] __________________________________________________________________________________________________ encoder_0/ffn_layernormalizatio (None, 256, 128) 256 tf.__operators__.add_2[0][0] __________________________________________________________________________________________________ mlm_cls (Dense) (None, 256, 30000) 3870000 encoder_0/ffn_layernormalization[ ================================================================================================== Total params: 7,809,584 Trainable params: 7,809,584 Non-trainable params: 0 __________________________________________________________________________________________________ Train and Save bert_masked_model.fit(mlm_ds, epochs=5, callbacks=[generator_callback]) bert_masked_model.save(\"bert_mlm_imdb.h5\") Epoch 1/5 1563/1563 [==============================] - ETA: 0s - loss: 7.0111{'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'this', 'prediction': 'i have watched this this and it was awesome', 'probability': 0.086307295} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'i', 'prediction': 'i have watched this i and it was awesome', 'probability': 0.066265985} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'movie', 'prediction': 'i have watched this movie and it was awesome', 'probability': 0.044195656} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'a', 'prediction': 'i have watched this a and it was awesome', 'probability': 0.04020928} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'was', 'prediction': 'i have watched this was and it was awesome', 'probability': 0.027878676} 1563/1563 [==============================] - 661s 423ms/step - loss: 7.0111 Epoch 2/5 1563/1563 [==============================] - ETA: 0s - loss: 6.4498{'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'movie', 'prediction': 'i have watched this movie and it was awesome', 'probability': 0.44448906} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'film', 'prediction': 'i have watched this film and it was awesome', 'probability': 0.1507494} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'is', 'prediction': 'i have watched this is and it was awesome', 'probability': 0.06385628} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'one', 'prediction': 'i have watched this one and it was awesome', 'probability': 0.023549262} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'was', 'prediction': 'i have watched this was and it was awesome', 'probability': 0.022277055} 1563/1563 [==============================] - 660s 422ms/step - loss: 6.4498 Epoch 3/5 1563/1563 [==============================] - ETA: 0s - loss: 5.8709{'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'movie', 'prediction': 'i have watched this movie and it was awesome', 'probability': 0.4759983} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'film', 'prediction': 'i have watched this film and it was awesome', 'probability': 0.18642229} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'one', 'prediction': 'i have watched this one and it was awesome', 'probability': 0.045611132} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'is', 'prediction': 'i have watched this is and it was awesome', 'probability': 0.028308254} {'input_text': 'i have watched this [mask] and it was awesome', 'predicted mask token': 'series', 'prediction': 'i have watched this series and it was awesome', 'probability': 0.027862877} 1563/1563 [==============================] - 661s 423ms/step - loss: 5.8709 Epoch 4/5 771/1563 [=============>................] - ETA: 5:35 - loss: 5.3782 Fine-tune a sentiment classification model We will fine-tune our self-supervised model on a downstream task of sentiment classification. To do this, let's create a classifier by adding a pooling layer and a Dense layer on top of the pretrained BERT features. # Load pretrained bert model mlm_model = keras.models.load_model( \"bert_mlm_imdb.h5\", custom_objects={\"MaskedLanguageModel\": MaskedLanguageModel} ) pretrained_bert_model = tf.keras.Model( mlm_model.input, mlm_model.get_layer(\"encoder_0/ffn_layernormalization\").output ) # Freeze it pretrained_bert_model.trainable = False def create_classifier_bert_model(): inputs = layers.Input((config.MAX_LEN,), dtype=tf.int64) sequence_output = pretrained_bert_model(inputs) pooled_output = layers.GlobalMaxPooling1D()(sequence_output) hidden_layer = layers.Dense(64, activation=\"relu\")(pooled_output) outputs = layers.Dense(1, activation=\"sigmoid\")(hidden_layer) classifer_model = keras.Model(inputs, outputs, name=\"classification\") optimizer = keras.optimizers.Adam() classifer_model.compile( optimizer=optimizer, loss=\"binary_crossentropy\", metrics=[\"accuracy\"] ) return classifer_model classifer_model = create_classifier_bert_model() classifer_model.summary() # Train the classifier with frozen BERT stage classifer_model.fit( train_classifier_ds, epochs=5, validation_data=test_classifier_ds, ) # Unfreeze the BERT model for fine-tuning pretrained_bert_model.trainable = True optimizer = keras.optimizers.Adam() classifer_model.compile( optimizer=optimizer, loss=\"binary_crossentropy\", metrics=[\"accuracy\"] ) classifer_model.fit( train_classifier_ds, epochs=5, validation_data=test_classifier_ds, ) Model: \"classification\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_2 (InputLayer) [(None, 256)] 0 _________________________________________________________________ model (Functional) (None, 256, 128) 3939584 _________________________________________________________________ global_max_pooling1d (Global (None, 128) 0 _________________________________________________________________ dense_2 (Dense) (None, 64) 8256 _________________________________________________________________ dense_3 (Dense) (None, 1) 65 ================================================================= Total params: 3,947,905 Trainable params: 8,321 Non-trainable params: 3,939,584 _________________________________________________________________ Epoch 1/5 782/782 [==============================] - 15s 19ms/step - loss: 0.8096 - accuracy: 0.5498 - val_loss: 0.6406 - val_accuracy: 0.6329 Epoch 2/5 782/782 [==============================] - 14s 18ms/step - loss: 0.6551 - accuracy: 0.6220 - val_loss: 0.6423 - val_accuracy: 0.6338 Epoch 3/5 782/782 [==============================] - 14s 18ms/step - loss: 0.6473 - accuracy: 0.6310 - val_loss: 0.6380 - val_accuracy: 0.6350 Epoch 4/5 782/782 [==============================] - 14s 18ms/step - loss: 0.6307 - accuracy: 0.6471 - val_loss: 0.6432 - val_accuracy: 0.6312 Epoch 5/5 782/782 [==============================] - 14s 18ms/step - loss: 0.6278 - accuracy: 0.6465 - val_loss: 0.6107 - val_accuracy: 0.6678 Epoch 1/5 782/782 [==============================] - 46s 59ms/step - loss: 0.5234 - accuracy: 0.7373 - val_loss: 0.3533 - val_accuracy: 0.8427 Epoch 2/5 782/782 [==============================] - 45s 57ms/step - loss: 0.2808 - accuracy: 0.8814 - val_loss: 0.3252 - val_accuracy: 0.8633 Epoch 3/5 782/782 [==============================] - 43s 55ms/step - loss: 0.1493 - accuracy: 0.9413 - val_loss: 0.4374 - val_accuracy: 0.8486 Epoch 4/5 782/782 [==============================] - 43s 55ms/step - loss: 0.0600 - accuracy: 0.9803 - val_loss: 0.6422 - val_accuracy: 0.8380 Epoch 5/5 782/782 [==============================] - 43s 55ms/step - loss: 0.0305 - accuracy: 0.9893 - val_loss: 0.6064 - val_accuracy: 0.8440 Create an end-to-end model and evaluate it When you want to deploy a model, it's best if it already includes its preprocessing pipeline, so that you don't have to reimplement the preprocessing logic in your production environment. Let's create an end-to-end model that incorporates the TextVectorization layer, and let's evaluate. Our model will accept raw strings as input. def get_end_to_end(model): inputs_string = keras.Input(shape=(1,), dtype=\"string\") indices = vectorize_layer(inputs_string) outputs = model(indices) end_to_end_model = keras.Model(inputs_string, outputs, name=\"end_to_end_model\") optimizer = keras.optimizers.Adam(learning_rate=config.LR) end_to_end_model.compile( optimizer=optimizer, loss=\"binary_crossentropy\", metrics=[\"accuracy\"] ) return end_to_end_model end_to_end_classification_model = get_end_to_end(classifer_model) end_to_end_classification_model.evaluate(test_raw_classifier_ds) 782/782 [==============================] - 8s 11ms/step - loss: 0.5967 - accuracy: 0.8446 [0.6064175963401794, 0.8439599871635437] Implementing a sequence-to-sequence Transformer and training it on a machine translation task. Introduction In this example, we'll build a sequence-to-sequence Transformer model, which we'll train on an English-to-Spanish machine translation task. You'll learn how to: Vectorize text using the Keras TextVectorization layer. Implement a TransformerEncoder layer, a TransformerDecoder layer, and a PositionalEmbedding layer. Prepare data for training a sequence-to-sequence model. Use the trained model to generate translations of never-seen-before input sentences (sequence-to-sequence inference). The code featured here is adapted from the book Deep Learning with Python, Second Edition (chapter 11: Deep learning for text). The present example is fairly barebones, so for detailed explanations of how each building block works, as well as the theory behind Transformers, I recommend reading the book. Setup import pathlib import random import string import re import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.layers import TextVectorization Downloading the data We'll be working with an English-to-Spanish translation dataset provided by Anki. Let's download it: text_file = keras.utils.get_file( fname=\"spa-eng.zip\", origin=\"http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip\", extract=True, ) text_file = pathlib.Path(text_file).parent / \"spa-eng\" / \"spa.txt\" Parsing the data Each line contains an English sentence and its corresponding Spanish sentence. The English sentence is the source sequence and Spanish one is the target sequence. We prepend the token \"[start]\" and we append the token \"[end]\" to the Spanish sentence. with open(text_file) as f: lines = f.read().split(\"\n\")[:-1] text_pairs = [] for line in lines: eng, spa = line.split(\"\t\") spa = \"[start] \" + spa + \" [end]\" text_pairs.append((eng, spa)) Here's what our sentence pairs look like: for _ in range(5): print(random.choice(text_pairs)) (\"You can dance, can't you?\", '[start] Puedes bailar, ¿verdad? [end]') ('I passed by her house yesterday.', '[start] Me pasé por su casa ayer. [end]') ('I like tulips.', '[start] Me gustan los tulipanes. [end]') ('He is fluent in French.', '[start] Habla un francés fluido. [end]') ('Tom asked me what I had been doing.', '[start] Tom me preguntó qué había estado haciendo. [end]') Now, let's split the sentence pairs into a training set, a validation set, and a test set. random.shuffle(text_pairs) num_val_samples = int(0.15 * len(text_pairs)) num_train_samples = len(text_pairs) - 2 * num_val_samples train_pairs = text_pairs[:num_train_samples] val_pairs = text_pairs[num_train_samples : num_train_samples + num_val_samples] test_pairs = text_pairs[num_train_samples + num_val_samples :] print(f\"{len(text_pairs)} total pairs\") print(f\"{len(train_pairs)} training pairs\") print(f\"{len(val_pairs)} validation pairs\") print(f\"{len(test_pairs)} test pairs\") 118964 total pairs 83276 training pairs 17844 validation pairs 17844 test pairs Vectorizing the text data We'll use two instances of the TextVectorization layer to vectorize the text data (one for English and one for Spanish), that is to say, to turn the original strings into integer sequences where each integer represents the index of a word in a vocabulary. The English layer will use the default string standardization (strip punctuation characters) and splitting scheme (split on whitespace), while the Spanish layer will use a custom standardization, where we add the character \"¿\" to the set of punctuation characters to be stripped. Note: in a production-grade machine translation model, I would not recommend stripping the punctuation characters in either language. Instead, I would recommend turning each punctuation character into its own token, which you could achieve by providing a custom split function to the TextVectorization layer. strip_chars = string.punctuation + \"¿\" strip_chars = strip_chars.replace(\"[\", \"\") strip_chars = strip_chars.replace(\"]\", \"\") vocab_size = 15000 sequence_length = 20 batch_size = 64 def custom_standardization(input_string): lowercase = tf.strings.lower(input_string) return tf.strings.regex_replace(lowercase, \"[%s]\" % re.escape(strip_chars), \"\") eng_vectorization = TextVectorization( max_tokens=vocab_size, output_mode=\"int\", output_sequence_length=sequence_length, ) spa_vectorization = TextVectorization( max_tokens=vocab_size, output_mode=\"int\", output_sequence_length=sequence_length + 1, standardize=custom_standardization, ) train_eng_texts = [pair[0] for pair in train_pairs] train_spa_texts = [pair[1] for pair in train_pairs] eng_vectorization.adapt(train_eng_texts) spa_vectorization.adapt(train_spa_texts) Next, we'll format our datasets. At each training step, the model will seek to predict target words N+1 (and beyond) using the source sentence and the target words 0 to N. As such, the training dataset will yield a tuple (inputs, targets), where: inputs is a dictionary with the keys encoder_inputs and decoder_inputs. encoder_inputs is the vectorized source sentence and encoder_inputs is the target sentence \"so far\", that is to say, the words 0 to N used to predict word N+1 (and beyond) in the target sentence. target is the target sentence offset by one step: it provides the next words in the target sentence -- what the model will try to predict. def format_dataset(eng, spa): eng = eng_vectorization(eng) spa = spa_vectorization(spa) return ({\"encoder_inputs\": eng, \"decoder_inputs\": spa[:, :-1],}, spa[:, 1:]) def make_dataset(pairs): eng_texts, spa_texts = zip(*pairs) eng_texts = list(eng_texts) spa_texts = list(spa_texts) dataset = tf.data.Dataset.from_tensor_slices((eng_texts, spa_texts)) dataset = dataset.batch(batch_size) dataset = dataset.map(format_dataset) return dataset.shuffle(2048).prefetch(16).cache() train_ds = make_dataset(train_pairs) val_ds = make_dataset(val_pairs) Let's take a quick look at the sequence shapes (we have batches of 64 pairs, and all sequences are 20 steps long): for inputs, targets in train_ds.take(1): print(f'inputs[\"encoder_inputs\"].shape: {inputs[\"encoder_inputs\"].shape}') print(f'inputs[\"decoder_inputs\"].shape: {inputs[\"decoder_inputs\"].shape}') print(f\"targets.shape: {targets.shape}\") inputs[\"encoder_inputs\"].shape: (64, 20) inputs[\"decoder_inputs\"].shape: (64, 20) targets.shape: (64, 20) Building the model Our sequence-to-sequence Transformer consists of a TransformerEncoder and a TransformerDecoder chained together. To make the model aware of word order, we also use a PositionalEmbedding layer. The source sequence will be pass to the TransformerEncoder, which will produce a new representation of it. This new representation will then be passed to the TransformerDecoder, together with the target sequence so far (target words 0 to N). The TransformerDecoder will then seek to predict the next words in the target sequence (N+1 and beyond). A key detail that makes this possible is causal masking (see method get_causal_attention_mask() on the TransformerDecoder). The TransformerDecoder sees the entire sequences at once, and thus we must make sure that it only uses information from target tokens 0 to N when predicting token N+1 (otherwise, it could use information from the future, which would result in a model that cannot be used at inference time). class TransformerEncoder(layers.Layer): def __init__(self, embed_dim, dense_dim, num_heads, **kwargs): super(TransformerEncoder, self).__init__(**kwargs) self.embed_dim = embed_dim self.dense_dim = dense_dim self.num_heads = num_heads self.attention = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim ) self.dense_proj = keras.Sequential( [layers.Dense(dense_dim, activation=\"relu\"), layers.Dense(embed_dim),] ) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() self.supports_masking = True def call(self, inputs, mask=None): if mask is not None: padding_mask = tf.cast(mask[:, tf.newaxis, tf.newaxis, :], dtype=\"int32\") attention_output = self.attention( query=inputs, value=inputs, key=inputs, attention_mask=padding_mask ) proj_input = self.layernorm_1(inputs + attention_output) proj_output = self.dense_proj(proj_input) return self.layernorm_2(proj_input + proj_output) class PositionalEmbedding(layers.Layer): def __init__(self, sequence_length, vocab_size, embed_dim, **kwargs): super(PositionalEmbedding, self).__init__(**kwargs) self.token_embeddings = layers.Embedding( input_dim=vocab_size, output_dim=embed_dim ) self.position_embeddings = layers.Embedding( input_dim=sequence_length, output_dim=embed_dim ) self.sequence_length = sequence_length self.vocab_size = vocab_size self.embed_dim = embed_dim def call(self, inputs): length = tf.shape(inputs)[-1] positions = tf.range(start=0, limit=length, delta=1) embedded_tokens = self.token_embeddings(inputs) embedded_positions = self.position_embeddings(positions) return embedded_tokens + embedded_positions def compute_mask(self, inputs, mask=None): return tf.math.not_equal(inputs, 0) class TransformerDecoder(layers.Layer): def __init__(self, embed_dim, latent_dim, num_heads, **kwargs): super(TransformerDecoder, self).__init__(**kwargs) self.embed_dim = embed_dim self.latent_dim = latent_dim self.num_heads = num_heads self.attention_1 = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim ) self.attention_2 = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim ) self.dense_proj = keras.Sequential( [layers.Dense(latent_dim, activation=\"relu\"), layers.Dense(embed_dim),] ) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() self.layernorm_3 = layers.LayerNormalization() self.supports_masking = True def call(self, inputs, encoder_outputs, mask=None): causal_mask = self.get_causal_attention_mask(inputs) if mask is not None: padding_mask = tf.cast(mask[:, tf.newaxis, :], dtype=\"int32\") padding_mask = tf.minimum(padding_mask, causal_mask) attention_output_1 = self.attention_1( query=inputs, value=inputs, key=inputs, attention_mask=causal_mask ) out_1 = self.layernorm_1(inputs + attention_output_1) attention_output_2 = self.attention_2( query=out_1, value=encoder_outputs, key=encoder_outputs, attention_mask=padding_mask, ) out_2 = self.layernorm_2(out_1 + attention_output_2) proj_output = self.dense_proj(out_2) return self.layernorm_3(out_2 + proj_output) def get_causal_attention_mask(self, inputs): input_shape = tf.shape(inputs) batch_size, sequence_length = input_shape[0], input_shape[1] i = tf.range(sequence_length)[:, tf.newaxis] j = tf.range(sequence_length) mask = tf.cast(i >= j, dtype=\"int32\") mask = tf.reshape(mask, (1, input_shape[1], input_shape[1])) mult = tf.concat( [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)], axis=0, ) return tf.tile(mask, mult) Next, we assemble the end-to-end model. embed_dim = 256 latent_dim = 2048 num_heads = 8 encoder_inputs = keras.Input(shape=(None,), dtype=\"int64\", name=\"encoder_inputs\") x = PositionalEmbedding(sequence_length, vocab_size, embed_dim)(encoder_inputs) encoder_outputs = TransformerEncoder(embed_dim, latent_dim, num_heads)(x) encoder = keras.Model(encoder_inputs, encoder_outputs) decoder_inputs = keras.Input(shape=(None,), dtype=\"int64\", name=\"decoder_inputs\") encoded_seq_inputs = keras.Input(shape=(None, embed_dim), name=\"decoder_state_inputs\") x = PositionalEmbedding(sequence_length, vocab_size, embed_dim)(decoder_inputs) x = TransformerDecoder(embed_dim, latent_dim, num_heads)(x, encoded_seq_inputs) x = layers.Dropout(0.5)(x) decoder_outputs = layers.Dense(vocab_size, activation=\"softmax\")(x) decoder = keras.Model([decoder_inputs, encoded_seq_inputs], decoder_outputs) decoder_outputs = decoder([decoder_inputs, encoder_outputs]) transformer = keras.Model( [encoder_inputs, decoder_inputs], decoder_outputs, name=\"transformer\" ) Training our model We'll use accuracy as a quick way to monitor training progress on the validation data. Note that machine translation typically uses BLEU scores as well as other metrics, rather than accuracy. Here we only train for 1 epoch, but to get the model to actually converge you should train for at least 30 epochs. epochs = 1 # This should be at least 30 for convergence transformer.summary() transformer.compile( \"rmsprop\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"] ) transformer.fit(train_ds, epochs=epochs, validation_data=val_ds) Model: \"transformer\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== encoder_inputs (InputLayer) [(None, None)] 0 __________________________________________________________________________________________________ positional_embedding (Positiona (None, None, 256) 3845120 encoder_inputs[0][0] __________________________________________________________________________________________________ decoder_inputs (InputLayer) [(None, None)] 0 __________________________________________________________________________________________________ transformer_encoder (Transforme (None, None, 256) 3155456 positional_embedding[0][0] __________________________________________________________________________________________________ model_1 (Functional) (None, None, 15000) 12959640 decoder_inputs[0][0] transformer_encoder[0][0] ================================================================================================== Total params: 19,960,216 Trainable params: 19,960,216 Non-trainable params: 0 __________________________________________________________________________________________________ 1302/1302 [==============================] - 1297s 993ms/step - loss: 1.6495 - accuracy: 0.4284 - val_loss: 1.2843 - val_accuracy: 0.5211 Decoding test sentences Finally, let's demonstrate how to translate brand new English sentences. We simply feed into the model the vectorized English sentence as well as the target token \"[start]\", then we repeatedly generated the next token, until we hit the token \"[end]\". spa_vocab = spa_vectorization.get_vocabulary() spa_index_lookup = dict(zip(range(len(spa_vocab)), spa_vocab)) max_decoded_sentence_length = 20 def decode_sequence(input_sentence): tokenized_input_sentence = eng_vectorization([input_sentence]) decoded_sentence = \"[start]\" for i in range(max_decoded_sentence_length): tokenized_target_sentence = spa_vectorization([decoded_sentence])[:, :-1] predictions = transformer([tokenized_input_sentence, tokenized_target_sentence]) sampled_token_index = np.argmax(predictions[0, i, :]) sampled_token = spa_index_lookup[sampled_token_index] decoded_sentence += \" \" + sampled_token if sampled_token == \"[end]\": break return decoded_sentence test_eng_texts = [pair[0] for pair in test_pairs] for _ in range(30): input_sentence = random.choice(test_eng_texts) translated = decode_sequence(input_sentence) After 30 epochs, we get results such as: She handed him the money. [start] ella le pasó el dinero [end] Tom has never heard Mary sing. [start] tom nunca ha oído cantar a mary [end] Perhaps she will come tomorrow. [start] tal vez ella vendrá mañana [end] I love to write. [start] me encanta escribir [end] His French is improving little by little. [start] su francés va a [UNK] sólo un poco [end] My hotel told me to call you. [start] mi hotel me dijo que te [UNK] [end] Implementing a large-scale multi-label text classification model. Introduction In this example, we will build a multi-label text classifier to predict the subject areas of arXiv papers from their abstract bodies. This type of classifier can be useful for conference submission portals like OpenReview. Given a paper abstract, the portal could provide suggestions for which areas the paper would best belong to. The dataset was collected using the arXiv Python library that provides a wrapper around the original arXiv API. To learn more about the data collection process, please refer to this notebook. Additionally, you can also find the dataset on Kaggle. Imports from tensorflow.keras import layers from tensorflow import keras import tensorflow as tf from sklearn.model_selection import train_test_split from ast import literal_eval import matplotlib.pyplot as plt import pandas as pd import numpy as np Perform exploratory data analysis In this section, we first load the dataset into a pandas dataframe and then perform some basic exploratory data analysis (EDA). arxiv_data = pd.read_csv( \"https://github.com/soumik12345/multi-label-text-classification/releases/download/v0.2/arxiv_data.csv\" ) arxiv_data.head() titles summaries terms 0 Survey on Semantic Stereo Matching / Semantic ... Stereo matching is one of the widely used tech... ['cs.CV', 'cs.LG'] 1 FUTURE-AI: Guiding Principles and Consensus Re... The recent advancements in artificial intellig... ['cs.CV', 'cs.AI', 'cs.LG'] 2 Enforcing Mutual Consistency of Hard Regions f... In this paper, we proposed a novel mutual cons... ['cs.CV', 'cs.AI'] 3 Parameter Decoupling Strategy for Semi-supervi... Consistency training has proven to be an advan... ['cs.CV'] 4 Background-Foreground Segmentation for Interio... To ensure safety in automated driving, the cor... ['cs.CV', 'cs.LG'] Our text features are present in the summaries column and their corresponding labels are in terms. As you can notice, there are multiple categories associated with a particular entry. print(f\"There are {len(arxiv_data)} rows in the dataset.\") There are 51774 rows in the dataset. Real-world data is noisy. One of the most commonly observed source of noise is data duplication. Here we notice that our initial dataset has got about 13k duplicate entries. total_duplicate_titles = sum(arxiv_data[\"titles\"].duplicated()) print(f\"There are {total_duplicate_titles} duplicate titles.\") There are 12802 duplicate titles. Before proceeding further, we drop these entries. arxiv_data = arxiv_data[~arxiv_data[\"titles\"].duplicated()] print(f\"There are {len(arxiv_data)} rows in the deduplicated dataset.\") # There are some terms with occurrence as low as 1. print(sum(arxiv_data[\"terms\"].value_counts() == 1)) # How many unique terms? print(arxiv_data[\"terms\"].nunique()) There are 38972 rows in the deduplicated dataset. 2321 3157 As observed above, out of 3,157 unique combinations of terms, 2,321 entries have the lowest occurrence. To prepare our train, validation, and test sets with stratification, we need to drop these terms. # Filtering the rare terms. arxiv_data_filtered = arxiv_data.groupby(\"terms\").filter(lambda x: len(x) > 1) arxiv_data_filtered.shape (36651, 3) Convert the string labels to lists of strings The initial labels are represented as raw strings. Here we make them List[str] for a more compact representation. arxiv_data_filtered[\"terms\"] = arxiv_data_filtered[\"terms\"].apply( lambda x: literal_eval(x) ) arxiv_data_filtered[\"terms\"].values[:5] array([list(['cs.CV', 'cs.LG']), list(['cs.CV', 'cs.AI', 'cs.LG']), list(['cs.CV', 'cs.AI']), list(['cs.CV']), list(['cs.CV', 'cs.LG'])], dtype=object) Use stratified splits because of class imbalance The dataset has a class imbalance problem. So, to have a fair evaluation result, we need to ensure the datasets are sampled with stratification. To know more about different strategies to deal with the class imbalance problem, you can follow this tutorial. For an end-to-end demonstration of classification with imbablanced data, refer to Imbalanced classification: credit card fraud detection. test_split = 0.1 # Initial train and test split. train_df, test_df = train_test_split( arxiv_data_filtered, test_size=test_split, stratify=arxiv_data_filtered[\"terms\"].values, ) # Splitting the test set further into validation # and new test sets. val_df = test_df.sample(frac=0.5) test_df.drop(val_df.index, inplace=True) print(f\"Number of rows in training set: {len(train_df)}\") print(f\"Number of rows in validation set: {len(val_df)}\") print(f\"Number of rows in test set: {len(test_df)}\") Number of rows in training set: 32985 Number of rows in validation set: 1833 Number of rows in test set: 1833 Multi-label binarization Now we preprocess our labels using the StringLookup layer. terms = tf.ragged.constant(train_df[\"terms\"].values) lookup = tf.keras.layers.StringLookup(output_mode=\"multi_hot\") lookup.adapt(terms) vocab = lookup.get_vocabulary() def invert_multi_hot(encoded_labels): \"\"\"Reverse a single multi-hot encoded label to a tuple of vocab terms.\"\"\" hot_indices = np.argwhere(encoded_labels == 1.0)[..., 0] return np.take(vocab, hot_indices) print(\"Vocabulary:\n\") print(vocab) Vocabulary: ['[UNK]', 'cs.CV', 'cs.LG', 'stat.ML', 'cs.AI', 'eess.IV', 'cs.RO', 'cs.CL', 'cs.NE', 'cs.CR', 'math.OC', 'eess.SP', 'cs.GR', 'cs.SI', 'cs.MM', 'cs.SY', 'cs.IR', 'cs.MA', 'eess.SY', 'cs.HC', 'math.IT', 'cs.IT', 'cs.DC', 'cs.CY', 'stat.AP', 'stat.TH', 'math.ST', 'stat.ME', 'eess.AS', 'cs.SD', 'q-bio.QM', 'q-bio.NC', 'cs.DS', 'cs.GT', 'cs.CG', 'cs.SE', 'cs.NI', 'I.2.6', 'stat.CO', 'math.NA', 'cs.NA', 'physics.chem-ph', 'cs.DB', 'q-bio.BM', 'cs.LO', 'cond-mat.dis-nn', '68T45', 'math.PR', 'cs.PL', 'physics.comp-ph', 'cs.CE', 'cs.AR', 'I.2.10', 'q-fin.ST', 'cond-mat.stat-mech', '68T05', 'math.DS', 'cs.CC', 'quant-ph', 'physics.data-an', 'I.4.6', 'physics.soc-ph', 'physics.ao-ph', 'econ.EM', 'cs.DM', 'q-bio.GN', 'physics.med-ph', 'cs.PF', 'astro-ph.IM', 'I.4.8', 'math.AT', 'I.4', 'q-fin.TR', 'cs.FL', 'I.5.4', 'I.2', '68U10', 'hep-ex', 'cond-mat.mtrl-sci', '68T10', 'physics.optics', 'physics.geo-ph', 'physics.flu-dyn', 'math.CO', 'math.AP', 'I.4; I.5', 'I.4.9', 'I.2.6; I.2.8', '68T01', '65D19', 'q-fin.CP', 'nlin.CD', 'cs.MS', 'I.2.6; I.5.1', 'I.2.10; I.4; I.5', 'I.2.0; I.2.6', '68T07', 'cs.SC', 'cs.ET', 'K.3.2', 'I.2; I.5', 'I.2.8', '68U01', '68T30', 'q-fin.GN', 'q-fin.EC', 'q-bio.MN', 'econ.GN', 'I.4.9; I.5.4', 'I.4.5', 'I.2; I.4; I.5', 'I.2.6; I.2.7', 'I.2.10; I.4.8', '68T99', '68Q32', '68', '62H30', 'q-fin.RM', 'q-fin.PM', 'q-bio.TO', 'q-bio.OT', 'physics.bio-ph', 'nlin.AO', 'math.LO', 'math.FA', 'hep-ph', 'cond-mat.soft', 'I.4.6; I.4.8', 'I.4.4', 'I.4.3', 'I.4.0', 'I.2; J.2', 'I.2; I.2.6; I.2.7', 'I.2.7', 'I.2.6; I.5.4', 'I.2.6; I.2.9', 'I.2.6; I.2.7; H.3.1; H.3.3', 'I.2.6; I.2.10', 'I.2.6, I.5.4', 'I.2.1; J.3', 'I.2.10; I.5.1; I.4.8', 'I.2.10; I.4.8; I.5.4', 'I.2.10; I.2.6', 'I.2.1', 'H.3.1; I.2.6; I.2.7', 'H.3.1; H.3.3; I.2.6; I.2.7', 'G.3', 'F.2.2; I.2.7', 'E.5; E.4; E.2; H.1.1; F.1.1; F.1.3', '68Txx', '62H99', '62H35', '14J60 (Primary) 14F05, 14J26 (Secondary)'] Here we are separating the individual unique classes available from the label pool and then using this information to represent a given label set with 0's and 1's. Below is an example. sample_label = train_df[\"terms\"].iloc[0] print(f\"Original label: {sample_label}\") label_binarized = lookup([sample_label]) print(f\"Label-binarized representation: {label_binarized}\") Original label: ['cs.LG', 'cs.CY'] Label-binarized representation: [[0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]] Data preprocessing and tf.data.Dataset objects We first get percentile estimates of the sequence lengths. The purpose will be clear in a moment. train_df[\"summaries\"].apply(lambda x: len(x.split(\" \"))).describe() count 32985.000000 mean 156.419706 std 41.528906 min 5.000000 25% 128.000000 50% 154.000000 75% 183.000000 max 462.000000 Name: summaries, dtype: float64 Notice that 50% of the abstracts have a length of 154 (you may get a different number based on the split). So, any number close to that value is a good enough approximate for the maximum sequence length. Now, we implement utilities to prepare our datasets that would go straight to the text classifier model. max_seqlen = 150 batch_size = 128 padding_token = \"\" auto = tf.data.AUTOTUNE def unify_text_length(text, label): # Split the given abstract and calculate its length. word_splits = tf.strings.split(text, sep=\" \") sequence_length = tf.shape(word_splits)[0] # Calculate the padding amount. padding_amount = max_seqlen - sequence_length # Check if we need to pad or truncate. if padding_amount > 0: unified_text = tf.pad([text], [[0, padding_amount]], constant_values=\"\") unified_text = tf.strings.reduce_join(unified_text, separator=\"\") else: unified_text = tf.strings.reduce_join(word_splits[:max_seqlen], separator=\" \") # The expansion is needed for subsequent vectorization. return tf.expand_dims(unified_text, -1), label def make_dataset(dataframe, is_train=True): labels = tf.ragged.constant(dataframe[\"terms\"].values) label_binarized = lookup(labels).numpy() dataset = tf.data.Dataset.from_tensor_slices( (dataframe[\"summaries\"].values, label_binarized) ) dataset = dataset.shuffle(batch_size * 10) if is_train else dataset dataset = dataset.map(unify_text_length, num_parallel_calls=auto).cache() return dataset.batch(batch_size) Now we can prepare the tf.data.Dataset objects. train_dataset = make_dataset(train_df, is_train=True) validation_dataset = make_dataset(val_df, is_train=False) test_dataset = make_dataset(test_df, is_train=False) Dataset preview text_batch, label_batch = next(iter(train_dataset)) for i, text in enumerate(text_batch[:5]): label = label_batch[i].numpy()[None, ...] print(f\"Abstract: {text[0]}\") print(f\"Label(s): {invert_multi_hot(label[0])}\") print(\" \") Abstract: b'For the integration of renewable energy sources, power grid operators need\nrealistic information about the effects of energy production and consumption to\nassess grid stability.\n Recently, research in scenario planning benefits from utilizing generative\nadversarial networks (GANs) as generative models for operational scenario\nplanning.\n In these scenarios, operators examine temporal as well as spatial influences\nof different energy sources on the grid.\n The analysis of how renewable energy resources affect the grid enables the\noperators to evaluate the stability and to identify potential weak points such\nas a limiting transformer.\n However, due to their novelty, there are limited studies on how well GANs\nmodel the underlying power distribution.\n This analysis is essential because, e.g., especially extreme situations with\nlow or high power generation are required to evaluate grid stability.\n We conduct a comparative study of the Wasserstein distance,\nbinary-cross-entropy loss, and a Gaussian copula as the baseline applied on two\nwind and two solar datasets' Label(s): ['cs.LG' 'eess.SP'] Abstract: b'We study the optimization problem for decomposing $d$ dimensional\nfourth-order Tensors with $k$ non-orthogonal components. We derive\n\\textit{deterministic} conditions under which such a problem does not have\nspurious local minima. In particular, we show that if $\\kappa =\n\\frac{\\lambda_{max}}{\\lambda_{min}} < \\frac{5}{4}$, and incoherence coefficient\nis of the order $O(\\frac{1}{\\sqrt{d}})$, then all the local minima are globally\noptimal. Using standard techniques, these conditions could be easily\ntransformed into conditions that would hold with high probability in high\ndimensions when the components are generated randomly. Finally, we prove that\nthe tensor power method with deflation and restarts could efficiently extract\nall the components within a tolerance level $O(\\kappa \\sqrt{k\\tau^3})$ that\nseems to be the noise floor of non-orthogonal tensor decomposition.' Label(s): ['cs.LG'] Abstract: b'Explainable Artificial Intelligence (XAI) is an emerging area of research in\nthe field of Artificial Intelligence (AI). XAI can explain how AI obtained a\nparticular solution (e.g., classification or object detection) and can also\nanswer other \"wh\" questions. This explainability is not possible in traditional\nAI. Explainability is essential for critical applications, such as defense,\nhealth care, law and order, and autonomous driving vehicles, etc, where the\nknow-how is required for trust and transparency. A number of XAI techniques so\nfar have been purposed for such applications. This paper provides an overview\nof these techniques from a multimedia (i.e., text, image, audio, and video)\npoint of view. The advantages and shortcomings of these techniques have been\ndiscussed, and pointers to some future directions have also been provided.' Label(s): ['cs.LG' 'cs.AI'] Abstract: b'Some of the most important tasks take place in environments which lack cheap\nand perfect simulators, thus hampering the application of model-free\nreinforcement learning (RL). While model-based RL aims to learn a dynamics\nmodel, in a more general case the learner does not know a priori what the\naction space is. Here we propose a formalism where the learner induces a world\nprogram by learning a dynamics model and the actions in graph-based\ncompositional environments by observing state-state transition examples. Then,\nthe learner can perform RL with the world program as the simulator for complex\nplanning tasks. We highlight a recent application, and propose a challenge for\nthe community to assess world program-based planning.' Label(s): ['cs.LG' 'stat.ML'] Abstract: b'Deep learning based image compression has recently witnessed exciting\nprogress and in some cases even managed to surpass transform coding based\napproaches that have been established and refined over many decades. However,\nstate-of-the-art solutions for deep image compression typically employ\nautoencoders which map the input to a lower dimensional latent space and thus\nirreversibly discard information already before quantization. Due to that, they\ninherently limit the range of quality levels that can be covered. In contrast,\ntraditional approaches in image compression allow for a larger range of quality\nlevels. Interestingly, they employ an invertible transformation before\nperforming the quantization step which explicitly discards information.\nInspired by this, we propose a deep image compression method that is able to go\nfrom low bit-rates to near lossless quality by leveraging normalizing flows to\nlearn a bijective mapping from the image space to a latent representation. In\naddition to this, we demonstrate further advantages unique to our solution,\nsuch as the ability to maintain constant quality results' Label(s): ['cs.CV'] Vectorization Before we feed the data to our model, we need to vectorize it (represent it in a numerical form). For that purpose, we will use the TextVectorization layer. It can operate as a part of your main model so that the model is excluded from the core preprocessing logic. This greatly reduces the chances of training / serving skew during inference. We first calculate the number of unique words present in the abstracts. train_df[\"total_words\"] = train_df[\"summaries\"].str.split().str.len() vocabulary_size = train_df[\"total_words\"].max() print(f\"Vocabulary size: {vocabulary_size}\") Vocabulary size: 498 We now create our vectorization layer and map() to the tf.data.Datasets created earlier. text_vectorizer = layers.TextVectorization( max_tokens=vocabulary_size, ngrams=2, output_mode=\"tf_idf\" ) # `TextVectorization` layer needs to be adapted as per the vocabulary from our # training set. with tf.device(\"/CPU:0\"): text_vectorizer.adapt(train_dataset.map(lambda text, label: text)) train_dataset = train_dataset.map( lambda text, label: (text_vectorizer(text), label), num_parallel_calls=auto ).prefetch(auto) validation_dataset = validation_dataset.map( lambda text, label: (text_vectorizer(text), label), num_parallel_calls=auto ).prefetch(auto) test_dataset = test_dataset.map( lambda text, label: (text_vectorizer(text), label), num_parallel_calls=auto ).prefetch(auto) A batch of raw text will first go through the TextVectorization layer and it will generate their integer representations. Internally, the TextVectorization layer will first create bi-grams out of the sequences and then represent them using TF-IDF. The output representations will then be passed to the shallow model responsible for text classification. To learn more about other possible configurations with TextVectorizer, please consult the official documentation. Note: Setting the max_tokens argument to a pre-calculated vocabulary size is not a requirement. Create a text classification model We will keep our model simple -- it will be a small stack of fully-connected layers with ReLU as the non-linearity. def make_model(): shallow_mlp_model = keras.Sequential( [ layers.Dense(512, activation=\"relu\"), layers.Dense(256, activation=\"relu\"), layers.Dense(lookup.vocabulary_size(), activation=\"sigmoid\"), ] # More on why \"sigmoid\" has been used here in a moment. ) return shallow_mlp_model Train the model We will train our model using the binary crossentropy loss. This is because the labels are not disjoint. For a given abstract, we may have multiple categories. So, we will divide the prediction task into a series of multiple binary classification problems. This is also why we kept the activation function of the classification layer in our model to sigmoid. Researchers have used other combinations of loss function and activation function as well. For example, in Exploring the Limits of Weakly Supervised Pretraining, Mahajan et al. used the softmax activation function and cross-entropy loss to train their models. epochs = 20 shallow_mlp_model = make_model() shallow_mlp_model.compile( loss=\"binary_crossentropy\", optimizer=\"adam\", metrics=[\"categorical_accuracy\"] ) history = shallow_mlp_model.fit( train_dataset, validation_data=validation_dataset, epochs=epochs ) def plot_result(item): plt.plot(history.history[item], label=item) plt.plot(history.history[\"val_\" + item], label=\"val_\" + item) plt.xlabel(\"Epochs\") plt.ylabel(item) plt.title(\"Train and Validation {} Over Epochs\".format(item), fontsize=14) plt.legend() plt.grid() plt.show() plot_result(\"loss\") plot_result(\"categorical_accuracy\") Epoch 1/20 258/258 [==============================] - 3s 7ms/step - loss: 0.0607 - categorical_accuracy: 0.8037 - val_loss: 0.0226 - val_categorical_accuracy: 0.8767 Epoch 2/20 258/258 [==============================] - 1s 5ms/step - loss: 0.0225 - categorical_accuracy: 0.8726 - val_loss: 0.0213 - val_categorical_accuracy: 0.8871 Epoch 3/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0215 - categorical_accuracy: 0.8750 - val_loss: 0.0210 - val_categorical_accuracy: 0.8893 Epoch 4/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0207 - categorical_accuracy: 0.8794 - val_loss: 0.0209 - val_categorical_accuracy: 0.8860 Epoch 5/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0201 - categorical_accuracy: 0.8823 - val_loss: 0.0208 - val_categorical_accuracy: 0.8882 Epoch 6/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0196 - categorical_accuracy: 0.8857 - val_loss: 0.0203 - val_categorical_accuracy: 0.8925 Epoch 7/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0191 - categorical_accuracy: 0.8876 - val_loss: 0.0196 - val_categorical_accuracy: 0.8914 Epoch 8/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0187 - categorical_accuracy: 0.8900 - val_loss: 0.0195 - val_categorical_accuracy: 0.8729 Epoch 9/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0183 - categorical_accuracy: 0.8919 - val_loss: 0.0193 - val_categorical_accuracy: 0.8800 Epoch 10/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0179 - categorical_accuracy: 0.8932 - val_loss: 0.0190 - val_categorical_accuracy: 0.8958 Epoch 11/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0176 - categorical_accuracy: 0.8950 - val_loss: 0.0192 - val_categorical_accuracy: 0.8974 Epoch 12/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0172 - categorical_accuracy: 0.8967 - val_loss: 0.0191 - val_categorical_accuracy: 0.8936 Epoch 13/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0169 - categorical_accuracy: 0.8980 - val_loss: 0.0192 - val_categorical_accuracy: 0.8920 Epoch 14/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0166 - categorical_accuracy: 0.8993 - val_loss: 0.0194 - val_categorical_accuracy: 0.8811 Epoch 15/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0162 - categorical_accuracy: 0.9008 - val_loss: 0.0196 - val_categorical_accuracy: 0.8822 Epoch 16/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0159 - categorical_accuracy: 0.9032 - val_loss: 0.0196 - val_categorical_accuracy: 0.8794 Epoch 17/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0156 - categorical_accuracy: 0.9047 - val_loss: 0.0197 - val_categorical_accuracy: 0.8652 Epoch 18/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0153 - categorical_accuracy: 0.9061 - val_loss: 0.0198 - val_categorical_accuracy: 0.8718 Epoch 19/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0150 - categorical_accuracy: 0.9067 - val_loss: 0.0200 - val_categorical_accuracy: 0.8734 Epoch 20/20 258/258 [==============================] - 1s 6ms/step - loss: 0.0146 - categorical_accuracy: 0.9087 - val_loss: 0.0202 - val_categorical_accuracy: 0.8691 png png While training, we notice an initial sharp fall in the loss followed by a gradual decay. Evaluate the model _, categorical_acc = shallow_mlp_model.evaluate(test_dataset) print(f\"Categorical accuracy on the test set: {round(categorical_acc * 100, 2)}%.\") 15/15 [==============================] - 0s 13ms/step - loss: 0.0208 - categorical_accuracy: 0.8642 Categorical accuracy on the test set: 86.42%. The trained model gives us an evaluation accuracy of ~87%. Inference An important feature of the preprocessing layers provided by Keras is that they can be included inside a tf.keras.Model. We will export an inference model by including the text_vectorization layer on top of shallow_mlp_model. This will allow our inference model to directly operate on raw strings. Note that during training it is always preferable to use these preprocessing layers as a part of the data input pipeline rather than the model to avoid surfacing bottlenecks for the hardware accelerators. This also allows for asynchronous data processing. # Create a model for inference. model_for_inference = keras.Sequential([text_vectorizer, shallow_mlp_model]) # Create a small dataset just for demoing inference. inference_dataset = make_dataset(test_df.sample(100), is_train=False) text_batch, label_batch = next(iter(inference_dataset)) predicted_probabilities = model_for_inference.predict(text_batch) # Perform inference. for i, text in enumerate(text_batch[:5]): label = label_batch[i].numpy()[None, ...] print(f\"Abstract: {text[0]}\") print(f\"Label(s): {invert_multi_hot(label[0])}\") predicted_proba = [proba for proba in predicted_probabilities[i]] top_3_labels = [ x for _, x in sorted( zip(predicted_probabilities[i], lookup.get_vocabulary()), key=lambda pair: pair[0], reverse=True, ) ][:3] print(f\"Predicted Label(s): ({', '.join([label for label in top_3_labels])})\") print(\" \") Abstract: b'Learning interpretable and interpolatable latent representations has been an\nemerging research direction, allowi Training a multimodal model for predicting entailment. Introduction In this example, we will build and train a model for predicting multimodal entailment. We will be using the multimodal entailment dataset recently introduced by Google Research. What is multimodal entailment? On social media platforms, to audit and moderate content we may want to find answers to the following questions in near real-time: Does a given piece of information contradict the other? Does a given piece of information imply the other? In NLP, this task is called analyzing textual entailment. However, that's only when the information comes from text content. In practice, it's often the case the information available comes not just from text content, but from a multimodal combination of text, images, audio, video, etc. Multimodal entailment is simply the extension of textual entailment to a variety of new input modalities. Requirements This example requires TensorFlow 2.5 or higher. In addition, TensorFlow Hub and TensorFlow Text are required for the BERT model (Devlin et al.). These libraries can be installed using the following command: !pip install -q tensorflow_text Imports from sklearn.model_selection import train_test_split import matplotlib.pyplot as plt import pandas as pd import numpy as np import os import tensorflow as tf import tensorflow_hub as hub import tensorflow_text as text from tensorflow import keras Define a label map label_map = {\"Contradictory\": 0, \"Implies\": 1, \"NoEntailment\": 2} Collect the dataset The original dataset is available here. It comes with URLs of images which are hosted on Twitter's photo storage system called the Photo Blob Storage (PBS for short). We will be working with the downloaded images along with additional data that comes with the original dataset. Thanks to Nilabhra Roy Chowdhury who worked on preparing the image data. image_base_path = keras.utils.get_file( \"tweet_images\", \"https://github.com/sayakpaul/Multimodal-Entailment-Baseline/releases/download/v1.0.0/tweet_images.tar.gz\", untar=True, ) Read the dataset and apply basic preprocessing df = pd.read_csv( \"https://github.com/sayakpaul/Multimodal-Entailment-Baseline/raw/main/csvs/tweets.csv\" ) df.sample(10) id_1 text_1 image_1 id_2 text_2 image_2 label 291 1330800194863190016 #KLM1167 (B738): #AMS (Amsterdam) to #HEL (Van... http://pbs.twimg.com/media/EnfzuZAW4AE236p.png 1378695438480588802 #CKK205 (B77L): #PVG (Shanghai) to #AMS (Amste... http://pbs.twimg.com/media/EyIcMexXEAE6gia.png NoEntailment 37 1366581728312057856 Friends, interested all go to have a look!\n@j... http://pbs.twimg.com/media/EvcS1v4UcAEEXPO.jpg 1373810535066570759 Friends, interested all go to have a look!\n@f... http://pbs.twimg.com/media/ExDBZqwVIAQ4LWk.jpg Contradictory 315 1352551603258052608 #WINk Drops I have earned today🚀\n\nToday:1/22... http://pbs.twimg.com/media/EsTdcLLVcAIiFKT.jpg 1354636016234098688 #WINk Drops I have earned today☀\n\nToday:1/28... http://pbs.twimg.com/media/EsyhK-qU0AgfMAH.jpg NoEntailment 761 1379795999493853189 #buythedip Ready to FLY even HIGHER #pennysto... http://pbs.twimg.com/media/EyYFJCzWgAMfTrT.jpg 1380190250144792576 #buythedip Ready to FLY even HIGHER #pennysto... http://pbs.twimg.com/media/Eydrt0ZXAAMmbfv.jpg NoEntailment 146 1340185132293099523 I know sometimes I am weird to you.\n\nBecause... http://pbs.twimg.com/media/EplLRriWwAAJ2AE.jpg 1359755419883814913 I put my sword down and get on my knees to swe... http://pbs.twimg.com/media/Et7SWWeWYAICK-c.jpg NoEntailment 1351 1381256604926967813 Finally completed the skin rendering. Will sta... http://pbs.twimg.com/media/Eys1j7NVIAgF-YF.jpg 1381630932092784641 Hair rendering. Will finish the hair by tomorr... http://pbs.twimg.com/media/EyyKAoaUUAElm-e.jpg NoEntailment 368 1371883298805403649 📉 $LINK Number of Receiving Addresses (7d MA) ... http://pbs.twimg.com/media/EwnoltOWEAAS4mG.jpg 1373216720974979072 📉 $LINK Number of Receiving Addresses (7d MA) ... http://pbs.twimg.com/media/Ew6lVGYXEAE6Ugi.jpg NoEntailment 1112 1377679115159887873 April is National Distracted Driving Awareness... http://pbs.twimg.com/media/Ex5_u7UVIAARjQ2.jpg 1379075258448281608 April is Distracted Driving Awareness Month. ... http://pbs.twimg.com/media/EyN1YjpWUAMc5ak.jpg NoEntailment 264 1330727515741167619 ♥️Verse Of The Day♥️\n.\n#VerseOfTheDay #Quran... http://pbs.twimg.com/media/EnexnydXIAYuI11.jpg 1332623263495819264 ♥️Verse Of The Day♥️\n.\n#VerseOfTheDay #Quran... http://pbs.twimg.com/media/En5ty1VXUAATALP.jpg NoEntailment 865 1377784616275296261 No white picket fence can keep us in. #TBT 200... http://pbs.twimg.com/media/Ex7fzouWQAITAq8.jpg 1380175915804672012 Sometimes you just need to change your altitud... http://pbs.twimg.com/media/EydernQXIAk2g5v.jpg NoEntailment The columns we are interested in are the following: text_1 image_1 text_2 image_2 label The entailment task is formulated as the following: Given the pairs of (text_1, image_1) and (text_2, image_2) do they entail (or not entail or contradict) each other? We have the images already downloaded. image_1 is downloaded as id1 as its filename and image2 is downloaded as id2 as its filename. In the next step, we will add two more columns to df - filepaths of image_1s and image_2s. images_one_paths = [] images_two_paths = [] for idx in range(len(df)): current_row = df.iloc[idx] id_1 = current_row[\"id_1\"] id_2 = current_row[\"id_2\"] extentsion_one = current_row[\"image_1\"].split(\".\")[-1] extentsion_two = current_row[\"image_2\"].split(\".\")[-1] image_one_path = os.path.join(image_base_path, str(id_1) + f\".{extentsion_one}\") image_two_path = os.path.join(image_base_path, str(id_2) + f\".{extentsion_two}\") images_one_paths.append(image_one_path) images_two_paths.append(image_two_path) df[\"image_1_path\"] = images_one_paths df[\"image_2_path\"] = images_two_paths # Create another column containing the integer ids of # the string labels. df[\"label_idx\"] = df[\"label\"].apply(lambda x: label_map[x]) Dataset visualization def visualize(idx): current_row = df.iloc[idx] image_1 = plt.imread(current_row[\"image_1_path\"]) image_2 = plt.imread(current_row[\"image_2_path\"]) text_1 = current_row[\"text_1\"] text_2 = current_row[\"text_2\"] label = current_row[\"label\"] plt.subplot(1, 2, 1) plt.imshow(image_1) plt.axis(\"off\") plt.title(\"Image One\") plt.subplot(1, 2, 2) plt.imshow(image_1) plt.axis(\"off\") plt.title(\"Image Two\") plt.show() print(f\"Text one: {text_1}\") print(f\"Text two: {text_2}\") print(f\"Label: {label}\") random_idx = np.random.choice(len(df)) visualize(random_idx) random_idx = np.random.choice(len(df)) visualize(random_idx) png Text one: Friends, interested all go to have a look! @ThePartyGoddess @OurLadyAngels @BJsWholesale @Richard_Jeni @FashionLavidaG @RapaRooski @DMVTHING @DeMarcoReports @LobidaFo @DeMarcoMorgan https://t.co/cStULl7y7G Text two: Friends, interested all go to have a look! @smittyses @CYosabel @crum_7 @CrumDarrell @ElymalikU @jenloarn @SoCodiePrevost @roblowry82 @Crummy_14 @CSchmelzenbach https://t.co/IZphLTNzgl Label: Contradictory png Text one: 👟 KICK OFF @ MARDEN SPORTS COMPLEX We're underway in the Round 6 opener! 📺: @Foxtel, @kayosports 📱: My Football Live app https://t.co/wHSpvQaoGC #WLeague #ADLvMVC #AUFC #MVFC https://t.co/3Smp8KXm8W Text two: 👟 KICK OFF @ MARSDEN SPORTS COMPLEX We're underway in sunny Adelaide! 📺: @Foxtel, @kayosports 📱: My Football Live app https://t.co/wHSpvQaoGC #ADLvCBR #WLeague #AUFC #UnitedAlways https://t.co/fG1PyLQXM4 Label: NoEntailment Train/test split The dataset suffers from class imbalance problem. We can confirm that in the following cell. df[\"label\"].value_counts() NoEntailment 1182 Implies 109 Contradictory 109 Name: label, dtype: int64 To account for that we will go for a stratified split. # 10% for test train_df, test_df = train_test_split( df, test_size=0.1, stratify=df[\"label\"].values, random_state=42 ) # 5% for validation train_df, val_df = train_test_split( train_df, test_size=0.05, stratify=train_df[\"label\"].values, random_state=42 ) print(f\"Total training examples: {len(train_df)}\") print(f\"Total validation examples: {len(val_df)}\") print(f\"Total test examples: {len(test_df)}\") Total training examples: 1197 Total validation examples: 63 Total test examples: 140 Data input pipeline TensorFlow Hub provides variety of BERT family of models. Each of those models comes with a corresponding preprocessing layer. You can learn more about these models and their preprocessing layers from this resource. To keep the runtime of this example relatively short, we will use a smaller variant of the original BERT model. # Define TF Hub paths to the BERT encoder and its preprocessor bert_model_path = ( \"https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1\" ) bert_preprocess_path = \"https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3\" Our text preprocessing code mostly comes from this tutorial. You are highly encouraged to check out the tutorial to learn more about the input preprocessing. def make_bert_preprocessing_model(sentence_features, seq_length=128): \"\"\"Returns Model mapping string features to BERT inputs. Args: sentence_features: A list with the names of string-valued features. seq_length: An integer that defines the sequence length of BERT inputs. Returns: A Keras Model that can be called on a list or dict of string Tensors (with the order or names, resp., given by sentence_features) and returns a dict of tensors for input to BERT. \"\"\" input_segments = [ tf.keras.layers.Input(shape=(), dtype=tf.string, name=ft) for ft in sentence_features ] # Tokenize the text to word pieces. bert_preprocess = hub.load(bert_preprocess_path) tokenizer = hub.KerasLayer(bert_preprocess.tokenize, name=\"tokenizer\") segments = [tokenizer(s) for s in input_segments] # Optional: Trim segments in a smart way to fit seq_length. # Simple cases (like this example) can skip this step and let # the next step apply a default truncation to approximately equal lengths. truncated_segments = segments # Pack inputs. The details (start/end token ids, dict of output tensors) # are model-dependent, so this gets loaded from the SavedModel. packer = hub.KerasLayer( bert_preprocess.bert_pack_inputs, arguments=dict(seq_length=seq_length), name=\"packer\", ) model_inputs = packer(truncated_segments) return keras.Model(input_segments, model_inputs) bert_preprocess_model = make_bert_preprocessing_model([\"text_1\", \"text_2\"]) keras.utils.plot_model(bert_preprocess_model, show_shapes=True, show_dtype=True) png Run the preprocessor on a sample input idx = np.random.choice(len(train_df)) row = train_df.iloc[idx] sample_text_1, sample_text_2 = row[\"text_1\"], row[\"text_2\"] print(f\"Text 1: {sample_text_1}\") print(f\"Text 2: {sample_text_2}\") test_text = [np.array([sample_text_1]), np.array([sample_text_2])] text_preprocessed = bert_preprocess_model(test_text) print(\"Keys : \", list(text_preprocessed.keys())) print(\"Shape Word Ids : \", text_preprocessed[\"input_word_ids\"].shape) print(\"Word Ids : \", text_preprocessed[\"input_word_ids\"][0, :16]) print(\"Shape Mask : \", text_preprocessed[\"input_mask\"].shape) print(\"Input Mask : \", text_preprocessed[\"input_mask\"][0, :16]) print(\"Shape Type Ids : \", text_preprocessed[\"input_type_ids\"].shape) print(\"Type Ids : \", text_preprocessed[\"input_type_ids\"][0, :16]) Text 1: Renewables met 97% of Scotland's electricity demand in 2020!!!! https://t.co/wi5c9UFAUF https://t.co/arcuBgh0BP Text 2: Renewables met 97% of Scotland's electricity demand in 2020 https://t.co/SrhyqPnIkU https://t.co/LORgvTM7Sn Keys : ['input_mask', 'input_word_ids', 'input_type_ids'] Shape Word Ids : (1, 128) Word Ids : tf.Tensor( [ 101 13918 2015 2777 5989 1003 1997 3885 1005 1055 6451 5157 1999 12609 999 999], shape=(16,), dtype=int32) Shape Mask : (1, 128) Input Mask : tf.Tensor([1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1], shape=(16,), dtype=int32) Shape Type Ids : (1, 128) Type Ids : tf.Tensor([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], shape=(16,), dtype=int32) We will now create tf.data.Dataset objects from the dataframes. Note that the text inputs will be preprocessed as a part of the data input pipeline. But the preprocessing modules can also be a part of their corresponding BERT models. This helps reduce the training/serving skew and lets our models operate with raw text inputs. Follow this tutorial to learn more about how to incorporate the preprocessing modules directly inside the models. def dataframe_to_dataset(dataframe): columns = [\"image_1_path\", \"image_2_path\", \"text_1\", \"text_2\", \"label_idx\"] dataframe = dataframe[columns].copy() labels = dataframe.pop(\"label_idx\") ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels)) ds = ds.shuffle(buffer_size=len(dataframe)) return ds Preprocessing utilities resize = (128, 128) bert_input_features = [\"input_word_ids\", \"input_type_ids\", \"input_mask\"] def preprocess_image(image_path): extension = tf.strings.split(image_path)[-1] image = tf.io.read_file(image_path) if extension == b\"jpg\": image = tf.image.decode_jpeg(image, 3) else: image = tf.image.decode_png(image, 3) image = tf.image.resize(image, resize) return image def preprocess_text(text_1, text_2): text_1 = tf.convert_to_tensor([text_1]) text_2 = tf.convert_to_tensor([text_2]) output = bert_preprocess_model([text_1, text_2]) output = {feature: tf.squeeze(output[feature]) for feature in bert_input_features} return output def preprocess_text_and_image(sample): image_1 = preprocess_image(sample[\"image_1_path\"]) image_2 = preprocess_image(sample[\"image_2_path\"]) text = preprocess_text(sample[\"text_1\"], sample[\"text_2\"]) return {\"image_1\": image_1, \"image_2\": image_2, \"text\": text} Create the final datasets batch_size = 32 auto = tf.data.AUTOTUNE def prepare_dataset(dataframe, training=True): ds = dataframe_to_dataset(dataframe) if training: ds = ds.shuffle(len(train_df)) ds = ds.map(lambda x, y: (preprocess_text_and_image(x), y)).cache() ds = ds.batch(batch_size).prefetch(auto) return ds train_ds = prepare_dataset(train_df) validation_ds = prepare_dataset(val_df, False) test_ds = prepare_dataset(test_df, False) Model building utilities Our final model will accept two images along with their text counterparts. While the images will be directly fed to the model the text inputs will first be preprocessed and then will make it into the model. Below is a visual illustration of this approach: The model consists of the following elements: A standalone encoder for the images. We will use a ResNet50V2 pre-trained on the ImageNet-1k dataset for this. A standalone encoder for the images. A pre-trained BERT will be used for this. After extracting the individual embeddings, they will be projected in an identical space. Finally, their projections will be concatenated and be fed to the final classification layer. This is a multi-class classification problem involving the following classes: NoEntailment Implies Contradictory project_embeddings(), create_vision_encoder(), and create_text_encoder() utilities are referred from this example. Projection utilities def project_embeddings( embeddings, num_projection_layers, projection_dims, dropout_rate ): projected_embeddings = keras.layers.Dense(units=projection_dims)(embeddings) for _ in range(num_projection_layers): x = tf.nn.gelu(projected_embeddings) x = keras.layers.Dense(projection_dims)(x) x = keras.layers.Dropout(dropout_rate)(x) x = keras.layers.Add()([projected_embeddings, x]) projected_embeddings = keras.layers.LayerNormalization()(x) return projected_embeddings Vision encoder utilities def create_vision_encoder( num_projection_layers, projection_dims, dropout_rate, trainable=False ): # Load the pre-trained ResNet50V2 model to be used as the base encoder. resnet_v2 = keras.applications.ResNet50V2( include_top=False, weights=\"imagenet\", pooling=\"avg\" ) # Set the trainability of the base encoder. for layer in resnet_v2.layers: layer.trainable = trainable # Receive the images as inputs. image_1 = keras.Input(shape=(128, 128, 3), name=\"image_1\") image_2 = keras.Input(shape=(128, 128, 3), name=\"image_2\") # Preprocess the input image. preprocessed_1 = keras.applications.resnet_v2.preprocess_input(image_1) preprocessed_2 = keras.applications.resnet_v2.preprocess_input(image_2) # Generate the embeddings for the images using the resnet_v2 model # concatenate them. embeddings_1 = resnet_v2(preprocessed_1) embeddings_2 = resnet_v2(preprocessed_2) embeddings = keras.layers.Concatenate()([embeddings_1, embeddings_2]) # Project the embeddings produced by the model. outputs = project_embeddings( embeddings, num_projection_layers, projection_dims, dropout_rate ) # Create the vision encoder model. return keras.Model([image_1, image_2], outputs, name=\"vision_encoder\") Text encoder utilities def create_text_encoder( num_projection_layers, projection_dims, dropout_rate, trainable=False ): # Load the pre-trained BERT model to be used as the base encoder. bert = hub.KerasLayer(bert_model_path, name=\"bert\",) # Set the trainability of the base encoder. bert.trainable = trainable # Receive the text as inputs. bert_input_features = [\"input_type_ids\", \"input_mask\", \"input_word_ids\"] inputs = { feature: keras.Input(shape=(128,), dtype=tf.int32, name=feature) for feature in bert_input_features } # Generate embeddings for the preprocessed text using the BERT model. embeddings = bert(inputs)[\"pooled_output\"] # Project the embeddings produced by the model. outputs = project_embeddings( embeddings, num_projection_layers, projection_dims, dropout_rate ) # Create the text encoder model. return keras.Model(inputs, outputs, name=\"text_encoder\") Multimodal model utilities def create_multimodal_model( num_projection_layers=1, projection_dims=256, dropout_rate=0.1, vision_trainable=False, text_trainable=False, ): # Receive the images as inputs. image_1 = keras.Input(shape=(128, 128, 3), name=\"image_1\") image_2 = keras.Input(shape=(128, 128, 3), name=\"image_2\") # Receive the text as inputs. bert_input_features = [\"input_type_ids\", \"input_mask\", \"input_word_ids\"] text_inputs = { feature: keras.Input(shape=(128,), dtype=tf.int32, name=feature) for feature in bert_input_features } # Create the encoders. vision_encoder = create_vision_encoder( num_projection_layers, projection_dims, dropout_rate, vision_trainable ) text_encoder = create_text_encoder( num_projection_layers, projection_dims, dropout_rate, text_trainable ) # Fetch the embedding projections. vision_projections = vision_encoder([image_1, image_2]) text_projections = text_encoder(text_inputs) # Concatenate the projections and pass through the classification layer. concatenated = keras.layers.Concatenate()([vision_projections, text_projections]) outputs = keras.layers.Dense(3, activation=\"softmax\")(concatenated) return keras.Model([image_1, image_2, text_inputs], outputs) multimodal_model = create_multimodal_model() keras.utils.plot_model(multimodal_model, show_shapes=True) png You can inspect the structure of the individual encoders as well by setting the expand_nested argument of plot_model() to True. You are encouraged to play with the different hyperparameters involved in building this model and observe how the final performance is affected. Compile and train the model multimodal_model.compile( optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=\"accuracy\" ) history = multimodal_model.fit(train_ds, validation_data=validation_ds, epochs=10) Epoch 1/10 38/38 [==============================] - 49s 789ms/step - loss: 1.0014 - accuracy: 0.8229 - val_loss: 0.5514 - val_accuracy: 0.8571 Epoch 2/10 38/38 [==============================] - 3s 90ms/step - loss: 0.4019 - accuracy: 0.8814 - val_loss: 0.5866 - val_accuracy: 0.8571 Epoch 3/10 38/38 [==============================] - 3s 90ms/step - loss: 0.3557 - accuracy: 0.8897 - val_loss: 0.5929 - val_accuracy: 0.8571 Epoch 4/10 38/38 [==============================] - 3s 91ms/step - loss: 0.2877 - accuracy: 0.9006 - val_loss: 0.6272 - val_accuracy: 0.8571 Epoch 5/10 38/38 [==============================] - 3s 91ms/step - loss: 0.1796 - accuracy: 0.9398 - val_loss: 0.8545 - val_accuracy: 0.8254 Epoch 6/10 38/38 [==============================] - 3s 91ms/step - loss: 0.1292 - accuracy: 0.9566 - val_loss: 1.2276 - val_accuracy: 0.8413 Epoch 7/10 38/38 [==============================] - 3s 91ms/step - loss: 0.1015 - accuracy: 0.9666 - val_loss: 1.2914 - val_accuracy: 0.7778 Epoch 8/10 38/38 [==============================] - 3s 92ms/step - loss: 0.1253 - accuracy: 0.9524 - val_loss: 1.1944 - val_accuracy: 0.8413 Epoch 9/10 38/38 [==============================] - 3s 92ms/step - loss: 0.3064 - accuracy: 0.9131 - val_loss: 1.2162 - val_accuracy: 0.8095 Epoch 10/10 38/38 [==============================] - 3s 92ms/step - loss: 0.2212 - accuracy: 0.9248 - val_loss: 1.1080 - val_accuracy: 0.8413 Evaluate the model _, acc = multimodal_model.evaluate(test_ds) print(f\"Accuracy on the test set: {round(acc * 100, 2)}%.\") 5/5 [==============================] - 6s 1s/step - loss: 0.8390 - accuracy: 0.8429 Accuracy on the test set: 84.29%. Additional notes regarding training Incorporating regularization: The training logs suggest that the model is starting to overfit and may have benefitted from regularization. Dropout (Srivastava et al.) is a simple yet powerful regularization technique that we can use in our model. But how should we apply it here? We could always introduce Dropout (keras.layers.Dropout) in between different layers of the model. But here is another recipe. Our model expects inputs from two different data modalities. What if either of the modalities is not present during inference? To account for this, we can introduce Dropout to the individual projections just before they get concatenated: vision_projections = keras.layers.Dropout(rate)(vision_projections) text_projections = keras.layers.Dropout(rate)(text_projections) concatenated = keras.layers.Concatenate()([vision_projections, text_projections]) Attending to what matters: Do all parts of the images correspond equally to their textual counterparts? It's likely not the case. To make our model only focus on the most important bits of the images that relate well to their corresponding textual parts we can use \"cross-attention\": # Embeddings. vision_projections = vision_encoder([image_1, image_2]) text_projections = text_encoder(text_inputs) # Cross-attention (Luong-style). query_value_attention_seq = keras.layers.Attention(use_scale=True, dropout=0.2)( [vision_projections, text_projections] ) # Concatenate. concatenated = keras.layers.Concatenate()([vision_projections, text_projections]) contextual = keras.layers.Concatenate()([concatenated, query_value_attention_seq]) To see this in action, refer to this notebook. Handling class imbalance: The dataset suffers from class imbalance. Investigating the confusion matrix of the above model reveals that it performs poorly on the minority classes. If we had used a weighted loss then the training would have been more guided. You can check out this notebook that takes class-imbalance into account during model training. Using only text inputs: Also, what if we had only incorporated text inputs for the entailment task? Because of the nature of the text inputs encountered on social media platforms, text inputs alone would have hurt the final performance. Under a similar training setup, by only using text inputs we get to 67.14% top-1 accuracy on the same test set. Refer to this notebook for details. Finally, here is a table comparing different approaches taken for the entailment task: Type Standard Cross-entropy Loss-weighted Cross-entropy Focal Loss Multimodal 77.86% 67.86% 86.43% Only text 67.14% 11.43% 37.86% You can check out this repository to learn more about how the experiments were conducted to obtain these numbers. Final remarks The architecture we used in this example is too large for the number of data points available for training. It's going to benefit from more data. We used a smaller variant of the original BERT model. Chances are high that with a larger variant, this performance will be improved. TensorFlow Hub provides a number of different BERT models that you can experiment with. We kept the pre-trained models frozen. Fine-tuning them on the multimodal entailment task would could resulted in better performance. We built a simple baseline model for the multimodal entailment task. There are various approaches that have been proposed to tackle the entailment problem. This presentation deck from the Recognizing Multimodal Entailment tutorial provides a comprehensive overview. NER using the Transformers and data from CoNLL 2003 shared task. Introduction Named Entity Recognition (NER) is the process of identifying named entities in text. Example of named entities are: \"Person\", \"Location\", \"Organization\", \"Dates\" etc. NER is essentially a token classification task where every token is classified into one or more predetermined categories. In this exercise, we will train a simple Transformer based model to perform NER. We will be using the data from CoNLL 2003 shared task. For more information about the dataset, please visit the dataset website. However, since obtaining this data requires an additional step of getting a free license, we will be using HuggingFace's datasets library which contains a processed version of this dataset. Install the open source datasets library from HuggingFace We also download the script used to evaluate NER models. !pip3 install datasets !wget https://raw.githubusercontent.com/sighsmile/conlleval/master/conlleval.py import os import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from datasets import load_dataset from collections import Counter from conlleval import evaluate We will be using the transformer implementation from this fantastic example. Let's start by defining a TransformerBlock layer: class TransformerBlock(layers.Layer): def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1): super(TransformerBlock, self).__init__() self.att = keras.layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim ) self.ffn = keras.Sequential( [ keras.layers.Dense(ff_dim, activation=\"relu\"), keras.layers.Dense(embed_dim), ] ) self.layernorm1 = keras.layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = keras.layers.LayerNormalization(epsilon=1e-6) self.dropout1 = keras.layers.Dropout(rate) self.dropout2 = keras.layers.Dropout(rate) def call(self, inputs, training=False): attn_output = self.att(inputs, inputs) attn_output = self.dropout1(attn_output, training=training) out1 = self.layernorm1(inputs + attn_output) ffn_output = self.ffn(out1) ffn_output = self.dropout2(ffn_output, training=training) return self.layernorm2(out1 + ffn_output) Next, let's define a TokenAndPositionEmbedding layer: class TokenAndPositionEmbedding(layers.Layer): def __init__(self, maxlen, vocab_size, embed_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = keras.layers.Embedding( input_dim=vocab_size, output_dim=embed_dim ) self.pos_emb = keras.layers.Embedding(input_dim=maxlen, output_dim=embed_dim) def call(self, inputs): maxlen = tf.shape(inputs)[-1] positions = tf.range(start=0, limit=maxlen, delta=1) position_embeddings = self.pos_emb(positions) token_embeddings = self.token_emb(inputs) return token_embeddings + position_embeddings Build the NER model class as a keras.Model subclass class NERModel(keras.Model): def __init__( self, num_tags, vocab_size, maxlen=128, embed_dim=32, num_heads=2, ff_dim=32 ): super(NERModel, self).__init__() self.embedding_layer = TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) self.transformer_block = TransformerBlock(embed_dim, num_heads, ff_dim) self.dropout1 = layers.Dropout(0.1) self.ff = layers.Dense(ff_dim, activation=\"relu\") self.dropout2 = layers.Dropout(0.1) self.ff_final = layers.Dense(num_tags, activation=\"softmax\") def call(self, inputs, training=False): x = self.embedding_layer(inputs) x = self.transformer_block(x) x = self.dropout1(x, training=training) x = self.ff(x) x = self.dropout2(x, training=training) x = self.ff_final(x) return x Load the CoNLL 2003 dataset from the datasets library and process it conll_data = load_dataset(\"conll2003\") We will export this data to a tab-separated file format which will be easy to read as a tf.data.Dataset object. def export_to_file(export_file_path, data): with open(export_file_path, \"w\") as f: for record in data: ner_tags = record[\"ner_tags\"] tokens = record[\"tokens\"] f.write( str(len(tokens)) + \"\t\" + \"\t\".join(tokens) + \"\t\" + \"\t\".join(map(str, ner_tags)) + \"\n\" ) os.mkdir(\"data\") export_to_file(\"./data/conll_train.txt\", conll_data[\"train\"]) export_to_file(\"./data/conll_val.txt\", conll_data[\"validation\"]) Make the NER label lookup table NER labels are usually provided in IOB, IOB2 or IOBES formats. Checkout this link for more information: Wikipedia Note that we start our label numbering from 1 since 0 will be reserved for padding. We have a total of 10 labels: 9 from the NER dataset and one for padding. def make_tag_lookup_table(): iob_labels = [\"B\", \"I\"] ner_labels = [\"PER\", \"ORG\", \"LOC\", \"MISC\"] all_labels = [(label1, label2) for label2 in ner_labels for label1 in iob_labels] all_labels = [\"-\".join([a, b]) for a, b in all_labels] all_labels = [\"[PAD]\", \"O\"] + all_labels return dict(zip(range(0, len(all_labels) + 1), all_labels)) mapping = make_tag_lookup_table() print(mapping) {0: '[PAD]', 1: 'O', 2: 'B-PER', 3: 'I-PER', 4: 'B-ORG', 5: 'I-ORG', 6: 'B-LOC', 7: 'I-LOC', 8: 'B-MISC', 9: 'I-MISC'} Get a list of all tokens in the training dataset. This will be used to create the vocabulary. all_tokens = sum(conll_data[\"train\"][\"tokens\"], []) all_tokens_array = np.array(list(map(str.lower, all_tokens))) counter = Counter(all_tokens_array) print(len(counter)) num_tags = len(mapping) vocab_size = 20000 # We only take (vocab_size - 2) most commons words from the training data since # the `StringLookup` class uses 2 additional tokens - one denoting an unknown # token and another one denoting a masking token vocabulary = [token for token, count in counter.most_common(vocab_size - 2)] # The StringLook class will convert tokens to token IDs lookup_layer = keras.layers.StringLookup( vocabulary=vocabulary ) 21009 Create 2 new Dataset objects from the training and validation data train_data = tf.data.TextLineDataset(\"./data/conll_train.txt\") val_data = tf.data.TextLineDataset(\"./data/conll_val.txt\") Print out one line to make sure it looks good. The first record in the line is the number of tokens. After that we will have all the tokens followed by all the ner tags. print(list(train_data.take(1).as_numpy_iterator())) [b'9\tEU\trejects\tGerman\tcall\tto\tboycott\tBritish\tlamb\t.\t3\t0\t7\t0\t0\t0\t7\t0\t0'] We will be using the following map function to transform the data in the dataset: def map_record_to_training_data(record): record = tf.strings.split(record, sep=\"\t\") length = tf.strings.to_number(record[0], out_type=tf.int32) tokens = record[1 : length + 1] tags = record[length + 1 :] tags = tf.strings.to_number(tags, out_type=tf.int64) tags += 1 return tokens, tags def lowercase_and_convert_to_ids(tokens): tokens = tf.strings.lower(tokens) return lookup_layer(tokens) # We use `padded_batch` here because each record in the dataset has a # different length. batch_size = 32 train_dataset = ( train_data.map(map_record_to_training_data) .map(lambda x, y: (lowercase_and_convert_to_ids(x), y)) .padded_batch(batch_size) ) val_dataset = ( val_data.map(map_record_to_training_data) .map(lambda x, y: (lowercase_and_convert_to_ids(x), y)) .padded_batch(batch_size) ) ner_model = NERModel(num_tags, vocab_size, embed_dim=32, num_heads=4, ff_dim=64) We will be using a custom loss function that will ignore the loss from padded tokens. class CustomNonPaddingTokenLoss(keras.losses.Loss): def __init__(self, name=\"custom_ner_loss\"): super().__init__(name=name) def call(self, y_true, y_pred): loss_fn = keras.losses.SparseCategoricalCrossentropy( from_logits=True, reduction=keras.losses.Reduction.NONE ) loss = loss_fn(y_true, y_pred) mask = tf.cast((y_true > 0), dtype=tf.float32) loss = loss * mask return tf.reduce_sum(loss) / tf.reduce_sum(mask) loss = CustomNonPaddingTokenLoss() Compile and fit the model ner_model.compile(optimizer=\"adam\", loss=loss) ner_model.fit(train_dataset, epochs=10) def tokenize_and_convert_to_ids(text): tokens = text.split() return lowercase_and_convert_to_ids(tokens) # Sample inference using the trained model sample_input = tokenize_and_convert_to_ids( \"eu rejects german call to boycott british lamb\" ) sample_input = tf.reshape(sample_input, shape=[1, -1]) print(sample_input) output = ner_model.predict(sample_input) prediction = np.argmax(output, axis=-1)[0] prediction = [mapping[i] for i in prediction] # eu -> B-ORG, german -> B-MISC, british -> B-MISC print(prediction) Epoch 1/10 439/439 [==============================] - 13s 26ms/step - loss: 0.9300 Epoch 2/10 439/439 [==============================] - 11s 24ms/step - loss: 0.2997 Epoch 3/10 439/439 [==============================] - 11s 24ms/step - loss: 0.1544 Epoch 4/10 439/439 [==============================] - 11s 25ms/step - loss: 0.1129 Epoch 5/10 439/439 [==============================] - 11s 25ms/step - loss: 0.0875 Epoch 6/10 439/439 [==============================] - 11s 25ms/step - loss: 0.0696 Epoch 7/10 439/439 [==============================] - 11s 25ms/step - loss: 0.0597 Epoch 8/10 439/439 [==============================] - 11s 25ms/step - loss: 0.0509 Epoch 9/10 439/439 [==============================] - 11s 25ms/step - loss: 0.0461 Epoch 10/10 439/439 [==============================] - 11s 25ms/step - loss: 0.0408 tf.Tensor([[ 989 10951 205 629 7 3939 216 5774]], shape=(1, 8), dtype=int64) ['B-ORG', 'O', 'B-MISC', 'O', 'O', 'O', 'B-MISC', 'O'] Metrics calculation Here is a function to calculate the metrics. The function calculates F1 score for the overall NER dataset as well as individual scores for each NER tag. def calculate_metrics(dataset): all_true_tag_ids, all_predicted_tag_ids = [], [] for x, y in dataset: output = ner_model.predict(x) predictions = np.argmax(output, axis=-1) predictions = np.reshape(predictions, [-1]) true_tag_ids = np.reshape(y, [-1]) mask = (true_tag_ids > 0) & (predictions > 0) true_tag_ids = true_tag_ids[mask] predicted_tag_ids = predictions[mask] all_true_tag_ids.append(true_tag_ids) all_predicted_tag_ids.append(predicted_tag_ids) all_true_tag_ids = np.concatenate(all_true_tag_ids) all_predicted_tag_ids = np.concatenate(all_predicted_tag_ids) predicted_tags = [mapping[tag] for tag in all_predicted_tag_ids] real_tags = [mapping[tag] for tag in all_true_tag_ids] evaluate(real_tags, predicted_tags) calculate_metrics(val_dataset) processed 51362 tokens with 5942 phrases; found: 5504 phrases; correct: 3855. accuracy: 63.28%; (non-O) accuracy: 93.22%; precision: 70.04%; recall: 64.88%; FB1: 67.36 LOC: precision: 85.67%; recall: 78.12%; FB1: 81.72 1675 MISC: precision: 73.15%; recall: 65.29%; FB1: 69.00 823 ORG: precision: 56.05%; recall: 63.53%; FB1: 59.56 1520 PER: precision: 65.01%; recall: 52.44%; FB1: 58.05 1486 Conclusions In this exercise, we created a simple transformer based named entity recognition model. We trained it on the CoNLL 2003 shared task data and got an overall F1 score of around 70%. State of the art NER models fine-tuned on pretrained models such as BERT or ELECTRA can easily get much higher F1 score -between 90-95% on this dataset owing to the inherent knowledge of words as part of the pretraining process and the usage of subword tokenization. Implementation of a dual encoder model for retrieving images that match natural language queries. Introduction The example demonstrates how to build a dual encoder (also known as two-tower) neural network model to search for images using natural language. The model is inspired by the CLIP approach, introduced by Alec Radford et al. The idea is to train a vision encoder and a text encoder jointly to project the representation of images and their captions into the same embedding space, such that the caption embeddings are located near the embeddings of the images they describe. This example requires TensorFlow 2.4 or higher. In addition, TensorFlow Hub and TensorFlow Text are required for the BERT model, and TensorFlow Addons is required for the AdamW optimizer. These libraries can be installed using the following command: pip install -q -U tensorflow-hub tensorflow-text tensorflow-addons Setup import os import collections import json import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_hub as hub import tensorflow_text as text import tensorflow_addons as tfa import matplotlib.pyplot as plt import matplotlib.image as mpimg from tqdm import tqdm # Suppressing tf.hub warnings tf.get_logger().setLevel(\"ERROR\") Prepare the data We will use the MS-COCO dataset to train our dual encoder model. MS-COCO contains over 82,000 images, each of which has at least 5 different caption annotations. The dataset is usually used for image captioning tasks, but we can repurpose the image-caption pairs to train our dual encoder model for image search. Download and extract the data First, let's download the dataset, which consists of two compressed folders: one with images, and the other—with associated image captions. Note that the compressed images folder is 13GB in size. root_dir = \"datasets\" annotations_dir = os.path.join(root_dir, \"annotations\") images_dir = os.path.join(root_dir, \"train2014\") tfrecords_dir = os.path.join(root_dir, \"tfrecords\") annotation_file = os.path.join(annotations_dir, \"captions_train2014.json\") # Download caption annotation files if not os.path.exists(annotations_dir): annotation_zip = tf.keras.utils.get_file( \"captions.zip\", cache_dir=os.path.abspath(\".\"), origin=\"http://images.cocodataset.org/annotations/annotations_trainval2014.zip\", extract=True, ) os.remove(annotation_zip) # Download image files if not os.path.exists(images_dir): image_zip = tf.keras.utils.get_file( \"train2014.zip\", cache_dir=os.path.abspath(\".\"), origin=\"http://images.cocodataset.org/zips/train2014.zip\", extract=True, ) os.remove(image_zip) print(\"Dataset is downloaded and extracted successfully.\") with open(annotation_file, \"r\") as f: annotations = json.load(f)[\"annotations\"] image_path_to_caption = collections.defaultdict(list) for element in annotations: caption = f\"{element['caption'].lower().rstrip('.')}\" image_path = images_dir + \"/COCO_train2014_\" + \"%012d.jpg\" % (element[\"image_id\"]) image_path_to_caption[image_path].append(caption) image_paths = list(image_path_to_caption.keys()) print(f\"Number of images: {len(image_paths)}\") Downloading data from http://images.cocodataset.org/annotations/annotations_trainval2014.zip 252878848/252872794 [==============================] - 5s 0us/step Downloading data from http://images.cocodataset.org/zips/train2014.zip 13510574080/13510573713 [==============================] - 394s 0us/step Dataset is downloaded and extracted successfully. Number of images: 82783 Process and save the data to TFRecord files You can change the sample_size parameter to control many image-caption pairs will be used for training the dual encoder model. In this example we set train_size to 30,000 images, which is about 35% of the dataset. We use 2 captions for each image, thus producing 60,000 image-caption pairs. The size of the training set affects the quality of the produced encoders, but more examples would lead to longer training time. train_size = 30000 valid_size = 5000 captions_per_image = 2 images_per_file = 2000 train_image_paths = image_paths[:train_size] num_train_files = int(np.ceil(train_size / images_per_file)) train_files_prefix = os.path.join(tfrecords_dir, \"train\") valid_image_paths = image_paths[-valid_size:] num_valid_files = int(np.ceil(valid_size / images_per_file)) valid_files_prefix = os.path.join(tfrecords_dir, \"valid\") tf.io.gfile.makedirs(tfrecords_dir) def bytes_feature(value): return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) def create_example(image_path, caption): feature = { \"caption\": bytes_feature(caption.encode()), \"raw_image\": bytes_feature(tf.io.read_file(image_path).numpy()), } return tf.train.Example(features=tf.train.Features(feature=feature)) def write_tfrecords(file_name, image_paths): caption_list = [] image_path_list = [] for image_path in image_paths: captions = image_path_to_caption[image_path][:captions_per_image] caption_list.extend(captions) image_path_list.extend([image_path] * len(captions)) with tf.io.TFRecordWriter(file_name) as writer: for example_idx in range(len(image_path_list)): example = create_example( image_path_list[example_idx], caption_list[example_idx] ) writer.write(example.SerializeToString()) return example_idx + 1 def write_data(image_paths, num_files, files_prefix): example_counter = 0 for file_idx in tqdm(range(num_files)): file_name = files_prefix + \"-%02d.tfrecord\" % (file_idx) start_idx = images_per_file * file_idx end_idx = start_idx + images_per_file example_counter += write_tfrecords(file_name, image_paths[start_idx:end_idx]) return example_counter train_example_count = write_data(train_image_paths, num_train_files, train_files_prefix) print(f\"{train_example_count} training examples were written to tfrecord files.\") valid_example_count = write_data(valid_image_paths, num_valid_files, valid_files_prefix) print(f\"{valid_example_count} evaluation examples were written to tfrecord files.\") 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 15/15 [03:19<00:00, 13.27s/it] 0%| | 0/3 [00:00\", \" \") return tf.strings.regex_replace( stripped_html, f\"[{re.escape(string.punctuation)}]\", \"\" ) vectorizer = layers.TextVectorization( 3000, standardize=custom_standardization, output_sequence_length=150 ) # Adapting the dataset vectorizer.adapt( train_dataset.map(lambda x, y: x, num_parallel_calls=tf.data.AUTOTUNE).batch(256) ) def vectorize_text(text, label): text = vectorizer(text) return text, label train_dataset = train_dataset.map( vectorize_text, num_parallel_calls=tf.data.AUTOTUNE ).prefetch(tf.data.AUTOTUNE) pool_negatives = pool_negatives.map(vectorize_text, num_parallel_calls=tf.data.AUTOTUNE) pool_positives = pool_positives.map(vectorize_text, num_parallel_calls=tf.data.AUTOTUNE) val_dataset = val_dataset.batch(256).map( vectorize_text, num_parallel_calls=tf.data.AUTOTUNE ) test_dataset = test_dataset.batch(256).map( vectorize_text, num_parallel_calls=tf.data.AUTOTUNE ) Creating Helper Functions # Helper function for merging new history objects with older ones def append_history(losses, val_losses, accuracy, val_accuracy, history): losses = losses + history.history[\"loss\"] val_losses = val_losses + history.history[\"val_loss\"] accuracy = accuracy + history.history[\"binary_accuracy\"] val_accuracy = val_accuracy + history.history[\"val_binary_accuracy\"] return losses, val_losses, accuracy, val_accuracy # Plotter function def plot_history(losses, val_losses, accuracies, val_accuracies): plt.plot(losses) plt.plot(val_losses) plt.legend([\"train_loss\", \"val_loss\"]) plt.xlabel(\"Epochs\") plt.ylabel(\"Loss\") plt.show() plt.plot(accuracies) plt.plot(val_accuracies) plt.legend([\"train_accuracy\", \"val_accuracy\"]) plt.xlabel(\"Epochs\") plt.ylabel(\"Accuracy\") plt.show() Creating the Model We create a small bidirectional LSTM model. When using Active Learning, you should make sure that the model architecture is capable of overfitting to the initial data. Overfitting gives a strong hint that the model will have enough capacity for future, unseen data. def create_model(): model = keras.models.Sequential( [ layers.Input(shape=(150,)), layers.Embedding(input_dim=3000, output_dim=128), layers.Bidirectional(layers.LSTM(32, return_sequences=True)), layers.GlobalMaxPool1D(), layers.Dense(20, activation=\"relu\"), layers.Dropout(0.5), layers.Dense(1, activation=\"sigmoid\"), ] ) model.summary() return model Training on the entire dataset To show the effectiveness of Active Learning, we will first train the model on the entire dataset containing 40,000 labeled samples. This model will be used for comparison later. def train_full_model(full_train_dataset, val_dataset, test_dataset): model = create_model() model.compile( loss=\"binary_crossentropy\", optimizer=\"rmsprop\", metrics=[ keras.metrics.BinaryAccuracy(), keras.metrics.FalseNegatives(), keras.metrics.FalsePositives(), ], ) # We will save the best model at every epoch and load the best one for evaluation on the test set history = model.fit( full_train_dataset.batch(256), epochs=20, validation_data=val_dataset, callbacks=[ keras.callbacks.EarlyStopping(patience=4, verbose=1), keras.callbacks.ModelCheckpoint( \"FullModelCheckpoint.h5\", verbose=1, save_best_only=True ), ], ) # Plot history plot_history( history.history[\"loss\"], history.history[\"val_loss\"], history.history[\"binary_accuracy\"], history.history[\"val_binary_accuracy\"], ) # Loading the best checkpoint model = keras.models.load_model(\"FullModelCheckpoint.h5\") print(\"-\" * 100) print( \"Test set evaluation: \", model.evaluate(test_dataset, verbose=0, return_dict=True), ) print(\"-\" * 100) return model # Sampling the full train dataset to train on full_train_dataset = ( train_dataset.concatenate(pool_positives) .concatenate(pool_negatives) .cache() .shuffle(20000) ) # Training the full model full_dataset_model = train_full_model(full_train_dataset, val_dataset, test_dataset) Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= embedding (Embedding) (None, 150, 128) 384000 bidirectional (Bidirectiona (None, 150, 64) 41216 l) global_max_pooling1d (Globa (None, 64) 0 lMaxPooling1D) dense (Dense) (None, 20) 1300 dropout (Dropout) (None, 20) 0 dense_1 (Dense) (None, 1) 21 ================================================================= Total params: 426,537 Trainable params: 426,537 Non-trainable params: 0 _________________________________________________________________ Epoch 1/20 156/157 [============================>.] - ETA: 0s - loss: 0.5150 - binary_accuracy: 0.7615 - false_negatives: 3314.0000 - false_positives: 6210.0000 Epoch 00001: val_loss improved from inf to 0.47791, saving model to FullModelCheckpoint.h5 157/157 [==============================] - 25s 103ms/step - loss: 0.5148 - binary_accuracy: 0.7617 - false_negatives: 3316.0000 - false_positives: 6217.0000 - val_loss: 0.4779 - val_binary_accuracy: 0.7858 - val_false_negatives: 970.0000 - val_false_positives: 101.0000 Epoch 2/20 156/157 [============================>.] - ETA: 0s - loss: 0.3659 - binary_accuracy: 0.8500 - false_negatives: 2833.0000 - false_positives: 3158.0000 Epoch 00002: val_loss improved from 0.47791 to 0.35345, saving model to FullModelCheckpoint.h5 157/157 [==============================] - 9s 59ms/step - loss: 0.3656 - binary_accuracy: 0.8501 - false_negatives: 2836.0000 - false_positives: 3159.0000 - val_loss: 0.3535 - val_binary_accuracy: 0.8502 - val_false_negatives: 363.0000 - val_false_positives: 386.0000 Epoch 3/20 156/157 [============================>.] - ETA: 0s - loss: 0.3319 - binary_accuracy: 0.8653 - false_negatives: 2507.0000 - false_positives: 2873.0000 Epoch 00003: val_loss improved from 0.35345 to 0.33150, saving model to FullModelCheckpoint.h5 157/157 [==============================] - 9s 55ms/step - loss: 0.3319 - binary_accuracy: 0.8652 - false_negatives: 2512.0000 - false_positives: 2878.0000 - val_loss: 0.3315 - val_binary_accuracy: 0.8576 - val_false_negatives: 423.0000 - val_false_positives: 289.0000 Epoch 4/20 156/157 [============================>.] - ETA: 0s - loss: 0.3130 - binary_accuracy: 0.8764 - false_negatives: 2398.0000 - false_positives: 2538.0000 Epoch 00004: val_loss did not improve from 0.33150 157/157 [==============================] - 9s 55ms/step - loss: 0.3129 - binary_accuracy: 0.8763 - false_negatives: 2404.0000 - false_positives: 2542.0000 - val_loss: 0.3328 - val_binary_accuracy: 0.8586 - val_false_negatives: 263.0000 - val_false_positives: 444.0000 Epoch 5/20 156/157 [============================>.] - ETA: 0s - loss: 0.2918 - binary_accuracy: 0.8867 - false_negatives: 2141.0000 - false_positives: 2385.0000 Epoch 00005: val_loss did not improve from 0.33150 157/157 [==============================] - 9s 55ms/step - loss: 0.2917 - binary_accuracy: 0.8867 - false_negatives: 2143.0000 - false_positives: 2388.0000 - val_loss: 0.3762 - val_binary_accuracy: 0.8468 - val_false_negatives: 476.0000 - val_false_positives: 290.0000 Epoch 6/20 156/157 [============================>.] - ETA: 0s - loss: 0.2819 - binary_accuracy: 0.8901 - false_negatives: 2112.0000 - false_positives: 2277.0000 Epoch 00006: val_loss did not improve from 0.33150 157/157 [==============================] - 9s 55ms/step - loss: 0.2819 - binary_accuracy: 0.8902 - false_negatives: 2112.0000 - false_positives: 2282.0000 - val_loss: 0.4018 - val_binary_accuracy: 0.8312 - val_false_negatives: 694.0000 - val_false_positives: 150.0000 Epoch 7/20 156/157 [============================>.] - ETA: 0s - loss: 0.2650 - binary_accuracy: 0.8992 - false_negatives: 1902.0000 - false_positives: 2122.0000 Epoch 00007: val_loss improved from 0.33150 to 0.32843, saving model to FullModelCheckpoint.h5 157/157 [==============================] - 9s 55ms/step - loss: 0.2649 - binary_accuracy: 0.8992 - false_negatives: 1908.0000 - false_positives: 2123.0000 - val_loss: 0.3284 - val_binary_accuracy: 0.8578 - val_false_negatives: 274.0000 - val_false_positives: 437.0000 Epoch 8/20 157/157 [==============================] - ETA: 0s - loss: 0.2508 - binary_accuracy: 0.9051 - false_negatives: 1821.0000 - false_positives: 1974.0000 Epoch 00008: val_loss did not improve from 0.32843 157/157 [==============================] - 9s 55ms/step - loss: 0.2508 - binary_accuracy: 0.9051 - false_negatives: 1821.0000 - false_positives: 1974.0000 - val_loss: 0.4806 - val_binary_accuracy: 0.8194 - val_false_negatives: 788.0000 - val_false_positives: 115.0000 Epoch 9/20 156/157 [============================>.] - ETA: 0s - loss: 0.2377 - binary_accuracy: 0.9112 - false_negatives: 1771.0000 - false_positives: 1775.0000 Epoch 00009: val_loss did not improve from 0.32843 157/157 [==============================] - 9s 54ms/step - loss: 0.2378 - binary_accuracy: 0.9112 - false_negatives: 1775.0000 - false_positives: 1777.0000 - val_loss: 0.3378 - val_binary_accuracy: 0.8562 - val_false_negatives: 335.0000 - val_false_positives: 384.0000 Epoch 10/20 156/157 [============================>.] - ETA: 0s - loss: 0.2209 - binary_accuracy: 0.9195 - false_negatives: 1591.0000 - false_positives: 1623.0000 Epoch 00010: val_loss did not improve from 0.32843 157/157 [==============================] - 9s 55ms/step - loss: 0.2211 - binary_accuracy: 0.9195 - false_negatives: 1594.0000 - false_positives: 1627.0000 - val_loss: 0.3475 - val_binary_accuracy: 0.8556 - val_false_negatives: 425.0000 - val_false_positives: 297.0000 Epoch 11/20 156/157 [============================>.] - ETA: 0s - loss: 0.2060 - binary_accuracy: 0.9251 - false_negatives: 1512.0000 - false_positives: 1479.0000 Epoch 00011: val_loss did not improve from 0.32843 157/157 [==============================] - 9s 55ms/step - loss: 0.2061 - binary_accuracy: 0.9251 - false_negatives: 1517.0000 - false_positives: 1479.0000 - val_loss: 0.3823 - val_binary_accuracy: 0.8522 - val_false_negatives: 276.0000 - val_false_positives: 463.0000 Epoch 00011: early stopping png png ---------------------------------------------------------------------------------------------------- Test set evaluation: {'loss': 0.34183189272880554, 'binary_accuracy': 0.8579999804496765, 'false_negatives': 295.0, 'false_positives': 415.0} ---------------------------------------------------------------------------------------------------- Training via Active Learning The general process we follow when performing Active Learning is demonstrated below: Active Learning The pipeline can be summarized in five parts: Sample and annotate a small, balanced training dataset Train the model on this small subset Evaluate the model on a balanced testing set If the model satisfies the business criteria, deploy it in a real time setting If it doesn't pass the criteria, sample a few more samples according to the ratio of false positives and negatives, add them to the training set and repeat from step 2 till the model passes the tests or till all available data is exhausted. For the code below, we will perform sampling using the following formula: Ratio Sampling Active Learning techniques use callbacks extensively for progress tracking. We will be using model checkpointing and early stopping for this example. The patience parameter for Early Stopping can help minimize overfitting and the time required. We have set it patience=4 for now but since the model is robust, we can increase the patience level if desired. Note: We are not loading the checkpoint after the first training iteration. In my experience working on Active Learning techniques, this helps the model probe the newly formed loss landscape. Even if the model fails to improve in the second iteration, we will still gain insight about the possible future false positive and negative rates. This will help us sample a better set in the next iteration where the model will have a greater chance to improve. def train_active_learning_models( train_dataset, pool_negatives, pool_positives, val_dataset, test_dataset, num_iterations=3, sampling_size=5000, ): # Creating lists for storing metrics losses, val_losses, accuracies, val_accuracies = [], [], [], [] model = create_model() # We will monitor the false positives and false negatives predicted by our model # These will decide the subsequent sampling ratio for every Active Learning loop model.compile( loss=\"binary_crossentropy\", optimizer=\"rmsprop\", metrics=[ keras.metrics.BinaryAccuracy(), keras.metrics.FalseNegatives(), keras.metrics.FalsePositives(), ], ) # Defining checkpoints. # The checkpoint callback is reused throughout the training since it only saves the best overall model. checkpoint = keras.callbacks.ModelCheckpoint( \"AL_Model.h5\", save_best_only=True, verbose=1 ) # Here, patience is set to 4. This can be set higher if desired. early_stopping = keras.callbacks.EarlyStopping(patience=4, verbose=1) print(f\"Starting to train with {len(train_dataset)} samples\") # Initial fit with a small subset of the training set history = model.fit( train_dataset.cache().shuffle(20000).batch(256), epochs=20, validation_data=val_dataset, callbacks=[checkpoint, early_stopping], ) # Appending history losses, val_losses, accuracies, val_accuracies = append_history( losses, val_losses, accuracies, val_accuracies, history ) for iteration in range(num_iterations): # Getting predictions from previously trained model predictions = model.predict(test_dataset) # Generating labels from the output probabilities rounded = tf.where(tf.greater(predictions, 0.5), 1, 0) # Evaluating the number of zeros and ones incorrrectly classified _, _, false_negatives, false_positives = model.evaluate(test_dataset, verbose=0) print(\"-\" * 100) print( f\"Number of zeros incorrectly classified: {false_negatives}, Number of ones incorrectly classified: {false_positives}\" ) # This technique of Active Learning demonstrates ratio based sampling where # Number of ones/zeros to sample = Number of ones/zeros incorrectly classified / Total incorrectly classified if false_negatives != 0 and false_positives != 0: total = false_negatives + false_positives sample_ratio_ones, sample_ratio_zeros = ( false_positives / total, false_negatives / total, ) # In the case where all samples are correctly predicted, we can sample both classes equally else: sample_ratio_ones, sample_ratio_zeros = 0.5, 0.5 print( f\"Sample ratio for positives: {sample_ratio_ones}, Sample ratio for negatives:{sample_ratio_zeros}\" ) # Sample the required number of ones and zeros sampled_dataset = pool_negatives.take( int(sample_ratio_zeros * sampling_size) ).concatenate(pool_positives.take(int(sample_ratio_ones * sampling_size))) # Skip the sampled data points to avoid repetition of sample pool_negatives = pool_negatives.skip(int(sample_ratio_zeros * sampling_size)) pool_positives = pool_positives.skip(int(sample_ratio_ones * sampling_size)) # Concatenating the train_dataset with the sampled_dataset train_dataset = train_dataset.concatenate(sampled_dataset).prefetch( tf.data.AUTOTUNE ) print(f\"Starting training with {len(train_dataset)} samples\") print(\"-\" * 100) # We recompile the model to reset the optimizer states and retrain the model model.compile( loss=\"binary_crossentropy\", optimizer=\"rmsprop\", metrics=[ keras.metrics.BinaryAccuracy(), keras.metrics.FalseNegatives(), keras.metrics.FalsePositives(), ], ) history = model.fit( train_dataset.cache().shuffle(20000).batch(256), validation_data=val_dataset, epochs=20, callbacks=[ checkpoint, keras.callbacks.EarlyStopping(patience=4, verbose=1), ], ) # Appending the history losses, val_losses, accuracies, val_accuracies = append_history( losses, val_losses, accuracies, val_accuracies, history ) # Loading the best model from this training loop model = keras.models.load_model(\"AL_Model.h5\") # Plotting the overall history and evaluating the final model plot_history(losses, val_losses, accuracies, val_accuracies) print(\"-\" * 100) print( \"Test set evaluation: \", model.evaluate(test_dataset, verbose=0, return_dict=True), ) print(\"-\" * 100) return model active_learning_model = train_active_learning_models( train_dataset, pool_negatives, pool_positives, val_dataset, test_dataset ) Model: \"sequential_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= embedding_1 (Embedding) (None, 150, 128) 384000 bidirectional_1 (Bidirectio (None, 150, 64) 41216 nal) global_max_pooling1d_1 (Glo (None, 64) 0 balMaxPooling1D) dense_2 (Dense) (None, 20) 1300 dropout_1 (Dropout) (None, 20) 0 dense_3 (Dense) (None, 1) 21 ================================================================= Total params: 426,537 Trainable params: 426,537 Non-trainable params: 0 _________________________________________________________________ Starting to train with 15000 samples Epoch 1/20 59/59 [==============================] - ETA: 0s - loss: 0.6235 - binary_accuracy: 0.6679 - false_negatives_1: 3111.0000 - false_positives_1: 1870.0000 Epoch 00001: val_loss improved from inf to 0.43017, saving model to AL_Model.h5 59/59 [==============================] - 13s 87ms/step - loss: 0.6235 - binary_accuracy: 0.6679 - false_negatives_1: 3111.0000 - false_positives_1: 1870.0000 - val_loss: 0.4302 - val_binary_accuracy: 0.8286 - val_false_negatives_1: 513.0000 - val_false_positives_1: 344.0000 Epoch 2/20 58/59 [============================>.] - ETA: 0s - loss: 0.4381 - binary_accuracy: 0.8232 - false_negatives_1: 1412.0000 - false_positives_1: 1213.0000 Epoch 00002: val_loss improved from 0.43017 to 0.40090, saving model to AL_Model.h5 59/59 [==============================] - 4s 64ms/step - loss: 0.4373 - binary_accuracy: 0.8235 - false_negatives_1: 1423.0000 - false_positives_1: 1225.0000 - val_loss: 0.4009 - val_binary_accuracy: 0.8248 - val_false_negatives_1: 674.0000 - val_false_positives_1: 202.0000 Epoch 3/20 58/59 [============================>.] - ETA: 0s - loss: 0.3810 - binary_accuracy: 0.8544 - false_negatives_1: 1115.0000 - false_positives_1: 1047.0000 Epoch 00003: val_loss improved from 0.40090 to 0.36085, saving model to AL_Model.h5 59/59 [==============================] - 4s 61ms/step - loss: 0.3805 - binary_accuracy: 0.8545 - false_negatives_1: 1123.0000 - false_positives_1: 1060.0000 - val_loss: 0.3608 - val_binary_accuracy: 0.8408 - val_false_negatives_1: 231.0000 - val_false_positives_1: 565.0000 Epoch 4/20 58/59 [============================>.] - ETA: 0s - loss: 0.3436 - binary_accuracy: 0.8647 - false_negatives_1: 995.0000 - false_positives_1: 1014.0000 Epoch 00004: val_loss improved from 0.36085 to 0.35469, saving model to AL_Model.h5 59/59 [==============================] - 4s 61ms/step - loss: 0.3428 - binary_accuracy: 0.8654 - false_negatives_1: 999.0000 - false_positives_1: 1020.0000 - val_loss: 0.3547 - val_binary_accuracy: 0.8452 - val_false_negatives_1: 266.0000 - val_false_positives_1: 508.0000 Epoch 5/20 58/59 [============================>.] - ETA: 0s - loss: 0.3166 - binary_accuracy: 0.8834 - false_negatives_1: 835.0000 - false_positives_1: 897.0000 Epoch 00005: val_loss did not improve from 0.35469 59/59 [==============================] - 4s 60ms/step - loss: 0.3163 - binary_accuracy: 0.8835 - false_negatives_1: 839.0000 - false_positives_1: 908.0000 - val_loss: 0.3554 - val_binary_accuracy: 0.8508 - val_false_negatives_1: 382.0000 - val_false_positives_1: 364.0000 Epoch 6/20 58/59 [============================>.] - ETA: 0s - loss: 0.2935 - binary_accuracy: 0.8944 - false_negatives_1: 757.0000 - false_positives_1: 811.0000 Epoch 00006: val_loss did not improve from 0.35469 59/59 [==============================] - 4s 60ms/step - loss: 0.2938 - binary_accuracy: 0.8945 - false_negatives_1: 765.0000 - false_positives_1: 818.0000 - val_loss: 0.3718 - val_binary_accuracy: 0.8458 - val_false_negatives_1: 345.0000 - val_false_positives_1: 426.0000 Epoch 7/20 58/59 [============================>.] - ETA: 0s - loss: 0.2794 - binary_accuracy: 0.9003 - false_negatives_1: 732.0000 - false_positives_1: 748.0000 Epoch 00007: val_loss did not improve from 0.35469 59/59 [==============================] - 3s 59ms/step - loss: 0.2797 - binary_accuracy: 0.9001 - false_negatives_1: 749.0000 - false_positives_1: 749.0000 - val_loss: 0.3825 - val_binary_accuracy: 0.8406 - val_false_negatives_1: 228.0000 - val_false_positives_1: 569.0000 Epoch 8/20 58/59 [============================>.] - ETA: 0s - loss: 0.2526 - binary_accuracy: 0.9147 - false_negatives_1: 620.0000 - false_positives_1: 647.0000 Epoch 00008: val_loss did not improve from 0.35469 59/59 [==============================] - 4s 60ms/step - loss: 0.2561 - binary_accuracy: 0.9134 - false_negatives_1: 620.0000 - false_positives_1: 679.0000 - val_loss: 0.4109 - val_binary_accuracy: 0.8258 - val_false_negatives_1: 622.0000 - val_false_positives_1: 249.0000 Epoch 00008: early stopping ---------------------------------------------------------------------------------------------------- Number of zeros incorrectly classified: 665.0, Number of ones incorrectly classified: 234.0 Sample ratio for positives: 0.26028921023359286, Sample ratio for negatives:0.7397107897664071 Starting training with 19999 samples ---------------------------------------------------------------------------------------------------- Epoch 1/20 78/79 [============================>.] - ETA: 0s - loss: 0.2955 - binary_accuracy: 0.8902 - false_negatives_2: 1091.0000 - false_positives_2: 1101.0000 Epoch 00001: val_loss did not improve from 0.35469 79/79 [==============================] - 15s 83ms/step - loss: 0.2956 - binary_accuracy: 0.8901 - false_negatives_2: 1095.0000 - false_positives_2: 1102.0000 - val_loss: 0.4136 - val_binary_accuracy: 0.8238 - val_false_negatives_2: 156.0000 - val_false_positives_2: 725.0000 Epoch 2/20 78/79 [============================>.] - ETA: 0s - loss: 0.2657 - binary_accuracy: 0.9047 - false_negatives_2: 953.0000 - false_positives_2: 949.0000 Epoch 00002: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 61ms/step - loss: 0.2659 - binary_accuracy: 0.9047 - false_negatives_2: 954.0000 - false_positives_2: 951.0000 - val_loss: 0.4079 - val_binary_accuracy: 0.8386 - val_false_negatives_2: 510.0000 - val_false_positives_2: 297.0000 Epoch 3/20 78/79 [============================>.] - ETA: 0s - loss: 0.2475 - binary_accuracy: 0.9126 - false_negatives_2: 892.0000 - false_positives_2: 854.0000 Epoch 00003: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 58ms/step - loss: 0.2474 - binary_accuracy: 0.9126 - false_negatives_2: 893.0000 - false_positives_2: 855.0000 - val_loss: 0.4207 - val_binary_accuracy: 0.8364 - val_false_negatives_2: 228.0000 - val_false_positives_2: 590.0000 Epoch 4/20 78/79 [============================>.] - ETA: 0s - loss: 0.2319 - binary_accuracy: 0.9193 - false_negatives_2: 805.0000 - false_positives_2: 807.0000 Epoch 00004: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 57ms/step - loss: 0.2319 - binary_accuracy: 0.9192 - false_negatives_2: 807.0000 - false_positives_2: 808.0000 - val_loss: 0.4080 - val_binary_accuracy: 0.8310 - val_false_negatives_2: 264.0000 - val_false_positives_2: 581.0000 Epoch 5/20 78/79 [============================>.] - ETA: 0s - loss: 0.2133 - binary_accuracy: 0.9260 - false_negatives_2: 728.0000 - false_positives_2: 750.0000 Epoch 00005: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 57ms/step - loss: 0.2133 - binary_accuracy: 0.9259 - false_negatives_2: 729.0000 - false_positives_2: 752.0000 - val_loss: 0.4054 - val_binary_accuracy: 0.8394 - val_false_negatives_2: 371.0000 - val_false_positives_2: 432.0000 Epoch 6/20 78/79 [============================>.] - ETA: 0s - loss: 0.1982 - binary_accuracy: 0.9361 - false_negatives_2: 639.0000 - false_positives_2: 636.0000 Epoch 00006: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 57ms/step - loss: 0.1980 - binary_accuracy: 0.9362 - false_negatives_2: 639.0000 - false_positives_2: 636.0000 - val_loss: 0.5185 - val_binary_accuracy: 0.8284 - val_false_negatives_2: 590.0000 - val_false_positives_2: 268.0000 Epoch 7/20 78/79 [============================>.] - ETA: 0s - loss: 0.1887 - binary_accuracy: 0.9409 - false_negatives_2: 606.0000 - false_positives_2: 575.0000 Epoch 00007: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 57ms/step - loss: 0.1886 - binary_accuracy: 0.9408 - false_negatives_2: 606.0000 - false_positives_2: 577.0000 - val_loss: 0.6881 - val_binary_accuracy: 0.7886 - val_false_negatives_2: 893.0000 - val_false_positives_2: 164.0000 Epoch 8/20 78/79 [============================>.] - ETA: 0s - loss: 0.1778 - binary_accuracy: 0.9443 - false_negatives_2: 575.0000 - false_positives_2: 538.0000 Epoch 00008: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 57ms/step - loss: 0.1776 - binary_accuracy: 0.9443 - false_negatives_2: 575.0000 - false_positives_2: 538.0000 - val_loss: 0.5921 - val_binary_accuracy: 0.8244 - val_false_negatives_2: 634.0000 - val_false_positives_2: 244.0000 Epoch 9/20 78/79 [============================>.] - ETA: 0s - loss: 0.1598 - binary_accuracy: 0.9505 - false_negatives_2: 507.0000 - false_positives_2: 481.0000 Epoch 00009: val_loss did not improve from 0.35469 79/79 [==============================] - 5s 57ms/step - loss: 0.1597 - binary_accuracy: 0.9506 - false_negatives_2: 507.0000 - false_positives_2: 481.0000 - val_loss: 0.5393 - val_binary_accuracy: 0.8214 - val_false_negatives_2: 542.0000 - val_false_positives_2: 351.0000 Epoch 00009: early stopping ---------------------------------------------------------------------------------------------------- Number of zeros incorrectly classified: 270.0, Number of ones incorrectly classified: 498.0 Sample ratio for positives: 0.6484375, Sample ratio for negatives:0.3515625 Starting training with 24998 samples ---------------------------------------------------------------------------------------------------- Epoch 1/20 97/98 [============================>.] - ETA: 0s - loss: 0.3554 - binary_accuracy: 0.8609 - false_negatives_3: 1714.0000 - false_positives_3: 1739.0000 Epoch 00001: val_loss improved from 0.35469 to 0.34182, saving model to AL_Model.h5 98/98 [==============================] - 17s 82ms/step - loss: 0.3548 - binary_accuracy: 0.8613 - false_negatives_3: 1720.0000 - false_positives_3: 1748.0000 - val_loss: 0.3418 - val_binary_accuracy: 0.8528 - val_false_negatives_3: 369.0000 - val_false_positives_3: 367.0000 Epoch 2/20 97/98 [============================>.] - ETA: 0s - loss: 0.3176 - binary_accuracy: 0.8785 - false_negatives_3: 1473.0000 - false_positives_3: 1544.0000 Epoch 00002: val_loss did not improve from 0.34182 98/98 [==============================] - 6s 56ms/step - loss: 0.3179 - binary_accuracy: 0.8784 - false_negatives_3: 1479.0000 - false_positives_3: 1560.0000 - val_loss: 0.4785 - val_binary_accuracy: 0.8102 - val_false_negatives_3: 793.0000 - val_false_positives_3: 156.0000 Epoch 3/20 97/98 [============================>.] - ETA: 0s - loss: 0.2986 - binary_accuracy: 0.8893 - false_negatives_3: 1353.0000 - false_positives_3: 1396.0000 Epoch 00003: val_loss did not improve from 0.34182 98/98 [==============================] - 5s 56ms/step - loss: 0.2985 - binary_accuracy: 0.8893 - false_negatives_3: 1366.0000 - false_positives_3: 1402.0000 - val_loss: 0.3473 - val_binary_accuracy: 0.8542 - val_false_negatives_3: 340.0000 - val_false_positives_3: 389.0000 Epoch 4/20 97/98 [============================>.] - ETA: 0s - loss: 0.2822 - binary_accuracy: 0.8970 - false_negatives_3: 1253.0000 - false_positives_3: 1305.0000 Epoch 00004: val_loss did not improve from 0.34182 98/98 [==============================] - 6s 56ms/step - loss: 0.2820 - binary_accuracy: 0.8971 - false_negatives_3: 1257.0000 - false_positives_3: 1316.0000 - val_loss: 0.3849 - val_binary_accuracy: 0.8386 - val_false_negatives_3: 537.0000 - val_false_positives_3: 270.0000 Epoch 5/20 97/98 [============================>.] - ETA: 0s - loss: 0.2666 - binary_accuracy: 0.9047 - false_negatives_3: 1130.0000 - false_positives_3: 1237.0000 Epoch 00005: val_loss did not improve from 0.34182 98/98 [==============================] - 6s 56ms/step - loss: 0.2666 - binary_accuracy: 0.9048 - false_negatives_3: 1142.0000 - false_positives_3: 1238.0000 - val_loss: 0.3731 - val_binary_accuracy: 0.8444 - val_false_negatives_3: 251.0000 - val_false_positives_3: 527.0000 Epoch 00005: early stopping ---------------------------------------------------------------------------------------------------- Number of zeros incorrectly classified: 392.0, Number of ones incorrectly classified: 356.0 Sample ratio for positives: 0.47593582887700536, Sample ratio for negatives:0.5240641711229946 Starting training with 29997 samples ---------------------------------------------------------------------------------------------------- Epoch 1/20 117/118 [============================>.] - ETA: 0s - loss: 0.3345 - binary_accuracy: 0.8720 - false_negatives_4: 1835.0000 - false_positives_4: 1998.0000 Epoch 00001: val_loss did not improve from 0.34182 118/118 [==============================] - 20s 96ms/step - loss: 0.3343 - binary_accuracy: 0.8722 - false_negatives_4: 1835.0000 - false_positives_4: 1999.0000 - val_loss: 0.3478 - val_binary_accuracy: 0.8488 - val_false_negatives_4: 250.0000 - val_false_positives_4: 506.0000 Epoch 2/20 117/118 [============================>.] - ETA: 0s - loss: 0.3061 - binary_accuracy: 0.8842 - false_negatives_4: 1667.0000 - false_positives_4: 1801.0000 Epoch 00002: val_loss improved from 0.34182 to 0.33779, saving model to AL_Model.h5 118/118 [==============================] - 7s 56ms/step - loss: 0.3059 - binary_accuracy: 0.8843 - false_negatives_4: 1670.0000 - false_positives_4: 1802.0000 - val_loss: 0.3378 - val_binary_accuracy: 0.8534 - val_false_negatives_4: 335.0000 - val_false_positives_4: 398.0000 Epoch 3/20 117/118 [============================>.] - ETA: 0s - loss: 0.2923 - binary_accuracy: 0.8921 - false_negatives_4: 1626.0000 - false_positives_4: 1607.0000 Epoch 00003: val_loss did not improve from 0.33779 118/118 [==============================] - 7s 56ms/step - loss: 0.2923 - binary_accuracy: 0.8921 - false_negatives_4: 1626.0000 - false_positives_4: 1611.0000 - val_loss: 0.3413 - val_binary_accuracy: 0.8486 - val_false_negatives_4: 269.0000 - val_false_positives_4: 488.0000 Epoch 4/20 117/118 [============================>.] - ETA: 0s - loss: 0.2746 - binary_accuracy: 0.8997 - false_negatives_4: 1459.0000 - false_positives_4: 1546.0000 Epoch 00004: val_loss did not improve from 0.33779 118/118 [==============================] - 7s 55ms/step - loss: 0.2746 - binary_accuracy: 0.8996 - false_negatives_4: 1465.0000 - false_positives_4: 1546.0000 - val_loss: 0.3810 - val_binary_accuracy: 0.8326 - val_false_negatives_4: 169.0000 - val_false_positives_4: 668.0000 Epoch 5/20 117/118 [============================>.] - ETA: 0s - loss: 0.2598 - binary_accuracy: 0.9066 - false_negatives_4: 1336.0000 - false_positives_4: 1462.0000 Epoch 00005: val_loss did not improve from 0.33779 118/118 [==============================] - 7s 56ms/step - loss: 0.2597 - binary_accuracy: 0.9066 - false_negatives_4: 1337.0000 - false_positives_4: 1465.0000 - val_loss: 0.4038 - val_binary_accuracy: 0.8332 - val_false_negatives_4: 643.0000 - val_false_positives_4: 191.0000 Epoch 6/20 117/118 [============================>.] - ETA: 0s - loss: 0.2461 - binary_accuracy: 0.9132 - false_negatives_4: 1263.0000 - false_positives_4: 1337.0000 Epoch 00006: val_loss did not improve from 0.33779 118/118 [==============================] - 7s 55ms/step - loss: 0.2462 - binary_accuracy: 0.9132 - false_negatives_4: 1263.0000 - false_positives_4: 1341.0000 - val_loss: 0.3546 - val_binary_accuracy: 0.8500 - val_false_negatives_4: 359.0000 - val_false_positives_4: 391.0000 Epoch 00006: early stopping png png ---------------------------------------------------------------------------------------------------- Test set evaluation: {'loss': 0.34248775243759155, 'binary_accuracy': 0.854200005531311, 'false_negatives_4': 348.0, 'false_positives_4': 381.0} ---------------------------------------------------------------------------------------------------- Conclusion Active Learning is a growing area of research. This example demonstrates the cost-efficiency benefits of using Active Learning, as it eliminates the need to annotate large amounts of data, saving resources. The following are some noteworthy observations from this example: We only require 30,000 samples to reach the same (if not better) scores as the model trained on the full datatset. This means that in a real life setting, we save the effort required for annotating 10,000 images! The number of false negatives and false positives are well balanced at the end of the training as compared to the skewed ratio obtained from the full training. This makes the model slightly more useful in real life scenarios where both the labels hold equal importance. For further reading about the types of sampling ratios, training techniques or available open source libraries/implementations, you can refer to the resources below: Active Learning Literature Survey (Burr Settles, 2010). modAL: A Modular Active Learning framework. Google's unofficial Active Learning playground. Natural Language Inference by fine-tuning BERT model on SNLI Corpus. Introduction Semantic Similarity is the task of determining how similar two sentences are, in terms of what they mean. This example demonstrates the use of SNLI (Stanford Natural Language Inference) Corpus to predict sentence semantic similarity with Transformers. We will fine-tune a BERT model that takes two sentences as inputs and that outputs a similarity score for these two sentences. References BERT SNLI Setup Note: install HuggingFace transformers via pip install transformers (version >= 2.11.0). import numpy as np import pandas as pd import tensorflow as tf import transformers Configuration max_length = 128 # Maximum length of input sentence to the model. batch_size = 32 epochs = 2 # Labels in our dataset. labels = [\"contradiction\", \"entailment\", \"neutral\"] Load the Data !curl -LO https://raw.githubusercontent.com/MohamadMerchant/SNLI/master/data.tar.gz !tar -xvzf data.tar.gz # There are more than 550k samples in total; we will use 100k for this example. train_df = pd.read_csv(\"SNLI_Corpus/snli_1.0_train.csv\", nrows=100000) valid_df = pd.read_csv(\"SNLI_Corpus/snli_1.0_dev.csv\") test_df = pd.read_csv(\"SNLI_Corpus/snli_1.0_test.csv\") # Shape of the data print(f\"Total train samples : {train_df.shape[0]}\") print(f\"Total validation samples: {valid_df.shape[0]}\") print(f\"Total test samples: {valid_df.shape[0]}\") % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 11.1M 100 11.1M 0 0 5231k 0 0:00:02 0:00:02 --:--:-- 5231k SNLI_Corpus/ SNLI_Corpus/snli_1.0_dev.csv SNLI_Corpus/snli_1.0_train.csv SNLI_Corpus/snli_1.0_test.csv Total train samples : 100000 Total validation samples: 10000 Total test samples: 10000 Dataset Overview: sentence1: The premise caption that was supplied to the author of the pair. sentence2: The hypothesis caption that was written by the author of the pair. similarity: This is the label chosen by the majority of annotators. Where no majority exists, the label \"-\" is used (we will skip such samples here). Here are the \"similarity\" label values in our dataset: Contradiction: The sentences share no similarity. Entailment: The sentences have similar meaning. Neutral: The sentences are neutral. Let's look at one sample from the dataset: print(f\"Sentence1: {train_df.loc[1, 'sentence1']}\") print(f\"Sentence2: {train_df.loc[1, 'sentence2']}\") print(f\"Similarity: {train_df.loc[1, 'similarity']}\") Sentence1: A person on a horse jumps over a broken down airplane. Sentence2: A person is at a diner, ordering an omelette. Similarity: contradiction Preprocessing # We have some NaN entries in our train data, we will simply drop them. print(\"Number of missing values\") print(train_df.isnull().sum()) train_df.dropna(axis=0, inplace=True) Number of missing values similarity 0 sentence1 0 sentence2 3 dtype: int64 Distribution of our training targets. print(\"Train Target Distribution\") print(train_df.similarity.value_counts()) Train Target Distribution entailment 33384 contradiction 33310 neutral 33193 - 110 Name: similarity, dtype: int64 Distribution of our validation targets. print(\"Validation Target Distribution\") print(valid_df.similarity.value_counts()) Validation Target Distribution entailment 3329 contradiction 3278 neutral 3235 - 158 Name: similarity, dtype: int64 The value \"-\" appears as part of our training and validation targets. We will skip these samples. train_df = ( train_df[train_df.similarity != \"-\"] .sample(frac=1.0, random_state=42) .reset_index(drop=True) ) valid_df = ( valid_df[valid_df.similarity != \"-\"] .sample(frac=1.0, random_state=42) .reset_index(drop=True) ) One-hot encode training, validation, and test labels. train_df[\"label\"] = train_df[\"similarity\"].apply( lambda x: 0 if x == \"contradiction\" else 1 if x == \"entailment\" else 2 ) y_train = tf.keras.utils.to_categorical(train_df.label, num_classes=3) valid_df[\"label\"] = valid_df[\"similarity\"].apply( lambda x: 0 if x == \"contradiction\" else 1 if x == \"entailment\" else 2 ) y_val = tf.keras.utils.to_categorical(valid_df.label, num_classes=3) test_df[\"label\"] = test_df[\"similarity\"].apply( lambda x: 0 if x == \"contradiction\" else 1 if x == \"entailment\" else 2 ) y_test = tf.keras.utils.to_categorical(test_df.label, num_classes=3) Create a custom data generator class BertSemanticDataGenerator(tf.keras.utils.Sequence): \"\"\"Generates batches of data. Args: sentence_pairs: Array of premise and hypothesis input sentences. labels: Array of labels. batch_size: Integer batch size. shuffle: boolean, whether to shuffle the data. include_targets: boolean, whether to incude the labels. Returns: Tuples `([input_ids, attention_mask, `token_type_ids], labels)` (or just `[input_ids, attention_mask, `token_type_ids]` if `include_targets=False`) \"\"\" def __init__( self, sentence_pairs, labels, batch_size=batch_size, shuffle=True, include_targets=True, ): self.sentence_pairs = sentence_pairs self.labels = labels self.shuffle = shuffle self.batch_size = batch_size self.include_targets = include_targets # Load our BERT Tokenizer to encode the text. # We will use base-base-uncased pretrained model. self.tokenizer = transformers.BertTokenizer.from_pretrained( \"bert-base-uncased\", do_lower_case=True ) self.indexes = np.arange(len(self.sentence_pairs)) self.on_epoch_end() def __len__(self): # Denotes the number of batches per epoch. return len(self.sentence_pairs) // self.batch_size def __getitem__(self, idx): # Retrieves the batch of index. indexes = self.indexes[idx * self.batch_size : (idx + 1) * self.batch_size] sentence_pairs = self.sentence_pairs[indexes] # With BERT tokenizer's batch_encode_plus batch of both the sentences are # encoded together and separated by [SEP] token. encoded = self.tokenizer.batch_encode_plus( sentence_pairs.tolist(), add_special_tokens=True, max_length=max_length, return_attention_mask=True, return_token_type_ids=True, pad_to_max_length=True, return_tensors=\"tf\", ) # Convert batch of encoded features to numpy array. input_ids = np.array(encoded[\"input_ids\"], dtype=\"int32\") attention_masks = np.array(encoded[\"attention_mask\"], dtype=\"int32\") token_type_ids = np.array(encoded[\"token_type_ids\"], dtype=\"int32\") # Set to true if data generator is used for training/validation. if self.include_targets: labels = np.array(self.labels[indexes], dtype=\"int32\") return [input_ids, attention_masks, token_type_ids], labels else: return [input_ids, attention_masks, token_type_ids] def on_epoch_end(self): # Shuffle indexes after each epoch if shuffle is set to True. if self.shuffle: np.random.RandomState(42).shuffle(self.indexes) Build the model # Create the model under a distribution strategy scope. strategy = tf.distribute.MirroredStrategy() with strategy.scope(): # Encoded token ids from BERT tokenizer. input_ids = tf.keras.layers.Input( shape=(max_length,), dtype=tf.int32, name=\"input_ids\" ) # Attention masks indicates to the model which tokens should be attended to. attention_masks = tf.keras.layers.Input( shape=(max_length,), dtype=tf.int32, name=\"attention_masks\" ) # Token type ids are binary masks identifying different sequences in the model. token_type_ids = tf.keras.layers.Input( shape=(max_length,), dtype=tf.int32, name=\"token_type_ids\" ) # Loading pretrained BERT model. bert_model = transformers.TFBertModel.from_pretrained(\"bert-base-uncased\") # Freeze the BERT model to reuse the pretrained features without modifying them. bert_model.trainable = False bert_output = bert_model( input_ids, attention_mask=attention_masks, token_type_ids=token_type_ids ) sequence_output = bert_output.last_hidden_state pooled_output = bert_output.pooler_output # Add trainable layers on top of frozen layers to adapt the pretrained features on the new data. bi_lstm = tf.keras.layers.Bidirectional( tf.keras.layers.LSTM(64, return_sequences=True) )(sequence_output) # Applying hybrid pooling approach to bi_lstm sequence output. avg_pool = tf.keras.layers.GlobalAveragePooling1D()(bi_lstm) max_pool = tf.keras.layers.GlobalMaxPooling1D()(bi_lstm) concat = tf.keras.layers.concatenate([avg_pool, max_pool]) dropout = tf.keras.layers.Dropout(0.3)(concat) output = tf.keras.layers.Dense(3, activation=\"softmax\")(dropout) model = tf.keras.models.Model( inputs=[input_ids, attention_masks, token_type_ids], outputs=output ) model.compile( optimizer=tf.keras.optimizers.Adam(), loss=\"categorical_crossentropy\", metrics=[\"acc\"], ) print(f\"Strategy: {strategy}\") model.summary() HBox(children=(FloatProgress(value=0.0, description='Downloading', max=433.0, style=ProgressStyle(description_… HBox(children=(FloatProgress(value=0.0, description='Downloading', max=536063208.0, style=ProgressStyle(descri… Strategy: Model: \"functional_1\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_ids (InputLayer) [(None, 128)] 0 __________________________________________________________________________________________________ attention_masks (InputLayer) [(None, 128)] 0 __________________________________________________________________________________________________ token_type_ids (InputLayer) [(None, 128)] 0 __________________________________________________________________________________________________ tf_bert_model (TFBertModel) ((None, 128, 768), ( 109482240 input_ids[0][0] attention_masks[0][0] token_type_ids[0][0] __________________________________________________________________________________________________ bidirectional (Bidirectional) (None, 128, 128) 426496 tf_bert_model[0][0] __________________________________________________________________________________________________ global_average_pooling1d (Globa (None, 128) 0 bidirectional[0][0] __________________________________________________________________________________________________ global_max_pooling1d (GlobalMax (None, 128) 0 bidirectional[0][0] __________________________________________________________________________________________________ concatenate (Concatenate) (None, 256) 0 global_average_pooling1d[0][0] global_max_pooling1d[0][0] __________________________________________________________________________________________________ dropout_37 (Dropout) (None, 256) 0 concatenate[0][0] __________________________________________________________________________________________________ dense (Dense) (None, 3) 771 dropout_37[0][0] ================================================================================================== Total params: 109,909,507 Trainable params: 427,267 Non-trainable params: 109,482,240 __________________________________________________________________________________________________ Create train and validation data generators train_data = BertSemanticDataGenerator( train_df[[\"sentence1\", \"sentence2\"]].values.astype(\"str\"), y_train, batch_size=batch_size, shuffle=True, ) valid_data = BertSemanticDataGenerator( valid_df[[\"sentence1\", \"sentence2\"]].values.astype(\"str\"), y_val, batch_size=batch_size, shuffle=False, ) HBox(children=(FloatProgress(value=0.0, description='Downloading', max=231508.0, style=ProgressStyle(descripti… Train the Model Training is done only for the top layers to perform \"feature extraction\", which will allow the model to use the representations of the pretrained model. history = model.fit( train_data, validation_data=valid_data, epochs=epochs, use_multiprocessing=True, workers=-1, ) Epoch 1/2 3121/3121 [==============================] - 666s 213ms/step - loss: 0.6925 - acc: 0.7049 - val_loss: 0.5294 - val_acc: 0.7899 Epoch 2/2 3121/3121 [==============================] - 661s 212ms/step - loss: 0.5917 - acc: 0.7587 - val_loss: 0.4955 - val_acc: 0.8052 Fine-tuning This step must only be performed after the feature extraction model has been trained to convergence on the new data. This is an optional last step where bert_model is unfreezed and retrained with a very low learning rate. This can deliver meaningful improvement by incrementally adapting the pretrained features to the new data. # Unfreeze the bert_model. bert_model.trainable = True # Recompile the model to make the change effective. model.compile( optimizer=tf.keras.optimizers.Adam(1e-5), loss=\"categorical_crossentropy\", metrics=[\"accuracy\"], ) model.summary() Model: \"functional_1\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_ids (InputLayer) [(None, 128)] 0 __________________________________________________________________________________________________ attention_masks (InputLayer) [(None, 128)] 0 __________________________________________________________________________________________________ token_type_ids (InputLayer) [(None, 128)] 0 __________________________________________________________________________________________________ tf_bert_model (TFBertModel) ((None, 128, 768), ( 109482240 input_ids[0][0] attention_masks[0][0] token_type_ids[0][0] __________________________________________________________________________________________________ bidirectional (Bidirectional) (None, 128, 128) 426496 tf_bert_model[0][0] __________________________________________________________________________________________________ global_average_pooling1d (Globa (None, 128) 0 bidirectional[0][0] __________________________________________________________________________________________________ global_max_pooling1d (GlobalMax (None, 128) 0 bidirectional[0][0] __________________________________________________________________________________________________ concatenate (Concatenate) (None, 256) 0 global_average_pooling1d[0][0] global_max_pooling1d[0][0] __________________________________________________________________________________________________ dropout_37 (Dropout) (None, 256) 0 concatenate[0][0] __________________________________________________________________________________________________ dense (Dense) (None, 3) 771 dropout_37[0][0] ================================================================================================== Total params: 109,909,507 Trainable params: 109,909,507 Non-trainable params: 0 __________________________________________________________________________________________________ Train the entire model end-to-end history = model.fit( train_data, validation_data=valid_data, epochs=epochs, use_multiprocessing=True, workers=-1, ) Epoch 1/2 3121/3121 [==============================] - 1574s 504ms/step - loss: 0.4698 - accuracy: 0.8181 - val_loss: 0.3787 - val_accuracy: 0.8598 Epoch 2/2 3121/3121 [==============================] - 1569s 503ms/step - loss: 0.3516 - accuracy: 0.8702 - val_loss: 0.3416 - val_accuracy: 0.8757 Evaluate model on the test set test_data = BertSemanticDataGenerator( test_df[[\"sentence1\", \"sentence2\"]].values.astype(\"str\"), y_test, batch_size=batch_size, shuffle=False, ) model.evaluate(test_data, verbose=1) 312/312 [==============================] - 55s 177ms/step - loss: 0.3697 - accuracy: 0.8629 [0.3696725070476532, 0.8628805875778198] Inference on custom sentences def check_similarity(sentence1, sentence2): sentence_pairs = np.array([[str(sentence1), str(sentence2)]]) test_data = BertSemanticDataGenerator( sentence_pairs, labels=None, batch_size=1, shuffle=False, include_targets=False, ) proba = model.predict(test_data[0])[0] idx = np.argmax(proba) proba = f\"{proba[idx]: .2f}%\" pred = labels[idx] return pred, proba Check results on some example sentence pairs. sentence1 = \"Two women are observing something together.\" sentence2 = \"Two women are standing with their eyes closed.\" check_similarity(sentence1, sentence2) ('contradiction', ' 0.91%') Check results on some example sentence pairs. sentence1 = \"A smiling costumed woman is holding an umbrella\" sentence2 = \"A happy woman in a fairy costume holds an umbrella\" check_similarity(sentence1, sentence2) ('neutral', ' 0.88%') Check results on some example sentence pairs sentence1 = \"A soccer game with multiple males playing\" sentence2 = \"Some men are playing a sport\" check_similarity(sentence1, sentence2) ('entailment', ' 0.94%') A model that learns to add strings of numbers, e.g. '535+61'->'596'. Introduction In this example, we train a model to learn to add two numbers, provided as strings. Example: Input: \"535+61\" Output: \"596\" Input may optionally be reversed, which was shown to increase performance in many tasks in: Learning to Execute and [Sequence to Sequence Learning with Neural Networks]( http://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) Theoretically, sequence order inversion introduces shorter term dependencies between source and target for this problem. Results: For two digits (reversed): One layer LSTM (128 HN), 5k training examples = 99% train/test accuracy in 55 epochs Three digits (reversed): One layer LSTM (128 HN), 50k training examples = 99% train/test accuracy in 100 epochs Four digits (reversed): One layer LSTM (128 HN), 400k training examples = 99% train/test accuracy in 20 epochs Five digits (reversed): One layer LSTM (128 HN), 550k training examples = 99% train/test accuracy in 30 epochs Setup from tensorflow import keras from tensorflow.keras import layers import numpy as np # Parameters for the model and dataset. TRAINING_SIZE = 50000 DIGITS = 3 REVERSE = True # Maximum length of input is 'int + int' (e.g., '345+678'). Maximum length of # int is DIGITS. MAXLEN = DIGITS + 1 + DIGITS Generate the data class CharacterTable: \"\"\"Given a set of characters: + Encode them to a one-hot integer representation + Decode the one-hot or integer representation to their character output + Decode a vector of probabilities to their character output \"\"\" def __init__(self, chars): \"\"\"Initialize character table. # Arguments chars: Characters that can appear in the input. \"\"\" self.chars = sorted(set(chars)) self.char_indices = dict((c, i) for i, c in enumerate(self.chars)) self.indices_char = dict((i, c) for i, c in enumerate(self.chars)) def encode(self, C, num_rows): \"\"\"One-hot encode given string C. # Arguments C: string, to be encoded. num_rows: Number of rows in the returned one-hot encoding. This is used to keep the # of rows for each data the same. \"\"\" x = np.zeros((num_rows, len(self.chars))) for i, c in enumerate(C): x[i, self.char_indices[c]] = 1 return x def decode(self, x, calc_argmax=True): \"\"\"Decode the given vector or 2D array to their character output. # Arguments x: A vector or a 2D array of probabilities or one-hot representations; or a vector of character indices (used with `calc_argmax=False`). calc_argmax: Whether to find the character index with maximum probability, defaults to `True`. \"\"\" if calc_argmax: x = x.argmax(axis=-1) return \"\".join(self.indices_char[x] for x in x) # All the numbers, plus sign and space for padding. chars = \"0123456789+ \" ctable = CharacterTable(chars) questions = [] expected = [] seen = set() print(\"Generating data...\") while len(questions) < TRAINING_SIZE: f = lambda: int( \"\".join( np.random.choice(list(\"0123456789\")) for i in range(np.random.randint(1, DIGITS + 1)) ) ) a, b = f(), f() # Skip any addition questions we've already seen # Also skip any such that x+Y == Y+x (hence the sorting). key = tuple(sorted((a, b))) if key in seen: continue seen.add(key) # Pad the data with spaces such that it is always MAXLEN. q = \"{}+{}\".format(a, b) query = q + \" \" * (MAXLEN - len(q)) ans = str(a + b) # Answers can be of maximum size DIGITS + 1. ans += \" \" * (DIGITS + 1 - len(ans)) if REVERSE: # Reverse the query, e.g., '12+345 ' becomes ' 543+21'. (Note the # space used for padding.) query = query[::-1] questions.append(query) expected.append(ans) print(\"Total questions:\", len(questions)) Generating data... Total questions: 50000 Vectorize the data print(\"Vectorization...\") x = np.zeros((len(questions), MAXLEN, len(chars)), dtype=np.bool) y = np.zeros((len(questions), DIGITS + 1, len(chars)), dtype=np.bool) for i, sentence in enumerate(questions): x[i] = ctable.encode(sentence, MAXLEN) for i, sentence in enumerate(expected): y[i] = ctable.encode(sentence, DIGITS + 1) # Shuffle (x, y) in unison as the later parts of x will almost all be larger # digits. indices = np.arange(len(y)) np.random.shuffle(indices) x = x[indices] y = y[indices] # Explicitly set apart 10% for validation data that we never train over. split_at = len(x) - len(x) // 10 (x_train, x_val) = x[:split_at], x[split_at:] (y_train, y_val) = y[:split_at], y[split_at:] print(\"Training Data:\") print(x_train.shape) print(y_train.shape) print(\"Validation Data:\") print(x_val.shape) print(y_val.shape) Vectorization... Training Data: (45000, 7, 12) (45000, 4, 12) Validation Data: (5000, 7, 12) (5000, 4, 12) Build the model print(\"Build model...\") num_layers = 1 # Try to add more LSTM layers! model = keras.Sequential() # \"Encode\" the input sequence using a LSTM, producing an output of size 128. # Note: In a situation where your input sequences have a variable length, # use input_shape=(None, num_feature). model.add(layers.LSTM(128, input_shape=(MAXLEN, len(chars)))) # As the decoder RNN's input, repeatedly provide with the last output of # RNN for each time step. Repeat 'DIGITS + 1' times as that's the maximum # length of output, e.g., when DIGITS=3, max output is 999+999=1998. model.add(layers.RepeatVector(DIGITS + 1)) # The decoder RNN could be multiple layers stacked or a single layer. for _ in range(num_layers): # By setting return_sequences to True, return not only the last output but # all the outputs so far in the form of (num_samples, timesteps, # output_dim). This is necessary as TimeDistributed in the below expects # the first dimension to be the timesteps. model.add(layers.LSTM(128, return_sequences=True)) # Apply a dense layer to the every temporal slice of an input. For each of step # of the output sequence, decide which character should be chosen. model.add(layers.Dense(len(chars), activation=\"softmax\")) model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) model.summary() Build model... Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= lstm (LSTM) (None, 128) 72192 _________________________________________________________________ repeat_vector (RepeatVector) (None, 4, 128) 0 _________________________________________________________________ lstm_1 (LSTM) (None, 4, 128) 131584 _________________________________________________________________ dense (Dense) (None, 4, 12) 1548 ================================================================= Total params: 205,324 Trainable params: 205,324 Non-trainable params: 0 _________________________________________________________________ Train the model epochs = 30 batch_size = 32 # Train the model each generation and show predictions against the validation # dataset. for epoch in range(1, epochs): print() print(\"Iteration\", epoch) model.fit( x_train, y_train, batch_size=batch_size, epochs=1, validation_data=(x_val, y_val), ) # Select 10 samples from the validation set at random so we can visualize # errors. for i in range(10): ind = np.random.randint(0, len(x_val)) rowx, rowy = x_val[np.array([ind])], y_val[np.array([ind])] preds = np.argmax(model.predict(rowx), axis=-1) q = ctable.decode(rowx[0]) correct = ctable.decode(rowy[0]) guess = ctable.decode(preds[0], calc_argmax=False) print(\"Q\", q[::-1] if REVERSE else q, end=\" \") print(\"T\", correct, end=\" \") if correct == guess: print(\"- \" + guess) else: print(\"-\" + guess) Iteration 1 1407/1407 [==============================] - 8s 6ms/step - loss: 1.7622 - accuracy: 0.3571 - val_loss: 1.5618 - val_accuracy: 0.4175 Q 99+580 T 679 - 905 Q 800+652 T 1452 - 1311 Q 900+0 T 900 - 909 Q 26+12 T 38 - 22 Q 8+397 T 405 - 903 Q 14+478 T 492 - 441 Q 59+589 T 648 - 551 Q 653+77 T 730 - 601 Q 10+35 T 45 - 11 Q 51+185 T 236 - 211 Iteration 2 1407/1407 [==============================] - 8s 6ms/step - loss: 1.3387 - accuracy: 0.5005 - val_loss: 1.1605 - val_accuracy: 0.5726 Q 373+107 T 480 - 417 Q 910+771 T 1681 - 1610 Q 494+86 T 580 - 555 Q 829+503 T 1332 - 1283 Q 820+292 T 1112 - 1102 Q 276+741 T 1017 - 1000 Q 208+84 T 292 - 397 Q 28+349 T 377 - 377 Q 875+47 T 922 - 930 Q 654+81 T 735 - 720 Iteration 3 1407/1407 [==============================] - 8s 6ms/step - loss: 1.0369 - accuracy: 0.6144 - val_loss: 0.9534 - val_accuracy: 0.6291 Q 73+290 T 363 - 358 Q 284+928 T 1212 - 1202 Q 12+775 T 787 - 783 Q 652+651 T 1303 - 1302 Q 12+940 T 952 - 953 Q 10+89 T 99 - 10 Q 86+947 T 1033 - 1023 Q 866+10 T 876 - 873 Q 196+8 T 204 - 208 Q 3+763 T 766 - 763 Iteration 4 1407/1407 [==============================] - 8s 6ms/step - loss: 0.8553 - accuracy: 0.6862 - val_loss: 0.8083 - val_accuracy: 0.6976 Q 561+68 T 629 ☒ 625 Q 1+878 T 879 ☒ 875 Q 461+525 T 986 ☒ 988 Q 453+84 T 537 ☒ 535 Q 92+33 T 125 ☒ 121 Q 29+624 T 653 ☒ 651 Q 656+89 T 745 ☑ 745 Q 30+418 T 448 ☒ 455 Q 600+3 T 603 ☒ 605 Q 26+346 T 372 ☒ 375 Iteration 5 1407/1407 [==============================] - 8s 6ms/step - loss: 0.7516 - accuracy: 0.7269 - val_loss: 0.7113 - val_accuracy: 0.7427 Q 522+451 T 973 ☒ 978 Q 721+69 T 790 ☒ 784 Q 294+53 T 347 ☒ 344 Q 80+48 T 128 ☒ 121 Q 343+182 T 525 ☒ 524 Q 17+83 T 100 ☒ 90 Q 132+3 T 135 ☒ 134 Q 63+963 T 1026 ☒ 1028 Q 427+655 T 1082 ☒ 1084 Q 76+36 T 112 ☒ 114 Iteration 6 1407/1407 [==============================] - 8s 6ms/step - loss: 0.6492 - accuracy: 0.7639 - val_loss: 0.5625 - val_accuracy: 0.7868 Q 20+56 T 76 ☒ 77 Q 904+74 T 978 ☒ 979 Q 716+736 T 1452 ☒ 1451 Q 69+512 T 581 ☑ 581 Q 82+501 T 583 ☒ 584 Q 297+442 T 739 ☒ 730 Q 759+30 T 789 ☑ 789 Q 160+451 T 611 ☒ 612 Q 765+30 T 795 ☒ 796 Q 658+37 T 695 ☒ 694 Iteration 7 1407/1407 [==============================] - 8s 6ms/step - loss: 0.4077 - accuracy: 0.8595 - val_loss: 0.3167 - val_accuracy: 0.9025 Q 558+81 T 639 ☑ 639 Q 795+73 T 868 ☑ 868 Q 98+93 T 191 ☑ 191 Q 7+454 T 461 ☑ 461 Q 64+764 T 828 ☑ 828 Q 91+14 T 105 ☒ 104 Q 554+53 T 607 ☑ 607 Q 7+454 T 461 ☑ 461 Q 411+46 T 457 ☑ 457 Q 991+55 T 1046 ☑ 1046 Iteration 8 1407/1407 [==============================] - 8s 6ms/step - loss: 0.2317 - accuracy: 0.9354 - val_loss: 0.2460 - val_accuracy: 0.9119 Q 136+57 T 193 ☑ 193 Q 896+60 T 956 ☒ 957 Q 453+846 T 1299 ☑ 1299 Q 86+601 T 687 ☑ 687 Q 272+230 T 502 ☒ 503 Q 675+886 T 1561 ☒ 1551 Q 121+634 T 755 ☒ 745 Q 17+853 T 870 ☑ 870 Q 9+40 T 49 ☒ 40 Q 290+80 T 370 ☒ 481 Iteration 9 1407/1407 [==============================] - 8s 6ms/step - loss: 0.1434 - accuracy: 0.9665 - val_loss: 0.1223 - val_accuracy: 0.9686 Q 1+532 T 533 ☑ 533 Q 298+20 T 318 ☑ 318 Q 750+28 T 778 ☑ 778 Q 44+576 T 620 ☑ 620 Q 988+481 T 1469 ☒ 1479 Q 234+829 T 1063 ☑ 1063 Q 855+19 T 874 ☑ 874 Q 741+56 T 797 ☑ 797 Q 7+643 T 650 ☑ 650 Q 14+598 T 612 ☒ 613 Iteration 10 1407/1407 [==============================] - 8s 6ms/step - loss: 0.1024 - accuracy: 0.9764 - val_loss: 0.0948 - val_accuracy: 0.9750 Q 380+26 T 406 ☑ 406 Q 813+679 T 1492 ☒ 1592 Q 3+763 T 766 ☑ 766 Q 677+83 T 760 ☑ 760 Q 474+13 T 487 ☑ 487 Q 861+4 T 865 ☑ 865 Q 83+24 T 107 ☑ 107 Q 67+177 T 244 ☑ 244 Q 841+31 T 872 ☑ 872 Q 740+121 T 861 ☒ 871 Iteration 11 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0780 - accuracy: 0.9812 - val_loss: 0.0537 - val_accuracy: 0.9893 Q 199+36 T 235 ☑ 235 Q 970+78 T 1048 ☑ 1048 Q 21+610 T 631 ☑ 631 Q 36+686 T 722 ☑ 722 Q 476+488 T 964 ☑ 964 Q 583+1 T 584 ☑ 584 Q 72+408 T 480 ☑ 480 Q 0+141 T 141 ☑ 141 Q 858+837 T 1695 ☒ 1795 Q 27+346 T 373 ☑ 373 Iteration 12 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0481 - accuracy: 0.9900 - val_loss: 0.0298 - val_accuracy: 0.9965 Q 23+44 T 67 ☑ 67 Q 905+251 T 1156 ☑ 1156 Q 298+46 T 344 ☑ 344 Q 320+31 T 351 ☑ 351 Q 854+730 T 1584 ☑ 1584 Q 765+30 T 795 ☑ 795 Q 60+179 T 239 ☑ 239 Q 792+76 T 868 ☑ 868 Q 79+114 T 193 ☑ 193 Q 354+23 T 377 ☑ 377 Iteration 13 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0547 - accuracy: 0.9857 - val_loss: 0.0956 - val_accuracy: 0.9682 Q 4+568 T 572 ☑ 572 Q 199+867 T 1066 ☑ 1066 Q 77+727 T 804 ☑ 804 Q 47+385 T 432 ☑ 432 Q 21+20 T 41 ☑ 41 Q 18+521 T 539 ☑ 539 Q 409+58 T 467 ☑ 467 Q 201+99 T 300 ☒ 200 Q 46+205 T 251 ☑ 251 Q 613+984 T 1597 ☑ 1597 Iteration 14 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0445 - accuracy: 0.9889 - val_loss: 0.0364 - val_accuracy: 0.9914 Q 50+770 T 820 ☑ 820 Q 338+329 T 667 ☑ 667 Q 535+529 T 1064 ☑ 1064 Q 50+907 T 957 ☑ 957 Q 266+30 T 296 ☑ 296 Q 65+91 T 156 ☑ 156 Q 43+8 T 51 ☑ 51 Q 714+3 T 717 ☑ 717 Q 415+38 T 453 ☑ 453 Q 432+252 T 684 ☑ 684 Iteration 15 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0324 - accuracy: 0.9920 - val_loss: 0.0196 - val_accuracy: 0.9965 Q 748+45 T 793 ☑ 793 Q 457+2 T 459 ☑ 459 Q 205+30 T 235 ☑ 235 Q 16+402 T 418 ☑ 418 Q 810+415 T 1225 ☑ 1225 Q 917+421 T 1338 ☑ 1338 Q 803+68 T 871 ☑ 871 Q 66+351 T 417 ☑ 417 Q 901+3 T 904 ☑ 904 Q 26+897 T 923 ☑ 923 Iteration 16 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0353 - accuracy: 0.9906 - val_loss: 0.0174 - val_accuracy: 0.9966 Q 295+57 T 352 ☑ 352 Q 4+683 T 687 ☑ 687 Q 608+892 T 1500 ☒ 1400 Q 618+71 T 689 ☑ 689 Q 43+299 T 342 ☑ 342 Q 662+9 T 671 ☑ 671 Q 50+318 T 368 ☑ 368 Q 33+665 T 698 ☑ 698 Q 2+11 T 13 ☑ 13 Q 29+261 T 290 ☑ 290 Iteration 17 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0368 - accuracy: 0.9903 - val_loss: 0.0148 - val_accuracy: 0.9971 Q 4+568 T 572 ☑ 572 Q 121+316 T 437 ☑ 437 Q 78+662 T 740 ☑ 740 Q 883+47 T 930 ☑ 930 Q 696+78 T 774 ☑ 774 Q 23+921 T 944 ☑ 944 Q 768+813 T 1581 ☑ 1581 Q 1+586 T 587 ☑ 587 Q 276+92 T 368 ☑ 368 Q 623+9 T 632 ☑ 632 Iteration 18 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0317 - accuracy: 0.9917 - val_loss: 0.0119 - val_accuracy: 0.9985 Q 50+430 T 480 ☑ 480 Q 583+86 T 669 ☑ 669 Q 899+342 T 1241 ☑ 1241 Q 164+369 T 533 ☑ 533 Q 728+9 T 737 ☑ 737 Q 182+85 T 267 ☑ 267 Q 81+323 T 404 ☑ 404 Q 91+85 T 176 ☑ 176 Q 602+606 T 1208 ☑ 1208 Q 334+193 T 527 ☑ 527 Iteration 19 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0225 - accuracy: 0.9940 - val_loss: 0.0291 - val_accuracy: 0.9915 Q 416+636 T 1052 ☑ 1052 Q 224+330 T 554 ☑ 554 Q 347+8 T 355 ☑ 355 Q 918+890 T 1808 ☒ 1809 Q 12+852 T 864 ☑ 864 Q 535+93 T 628 ☑ 628 Q 476+98 T 574 ☑ 574 Q 89+682 T 771 ☑ 771 Q 731+99 T 830 ☑ 830 Q 222+45 T 267 ☑ 267 Iteration 20 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0325 - accuracy: 0.9914 - val_loss: 0.0118 - val_accuracy: 0.9980 Q 342+270 T 612 ☑ 612 Q 20+188 T 208 ☑ 208 Q 37+401 T 438 ☑ 438 Q 672+417 T 1089 ☑ 1089 Q 597+12 T 609 ☑ 609 Q 569+81 T 650 ☑ 650 Q 58+46 T 104 ☑ 104 Q 48+46 T 94 ☑ 94 Q 801+47 T 848 ☑ 848 Q 356+550 T 906 ☑ 906 Iteration 21 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0226 - accuracy: 0.9941 - val_loss: 0.0097 - val_accuracy: 0.9984 Q 77+188 T 265 ☑ 265 Q 449+35 T 484 ☑ 484 Q 76+287 T 363 ☑ 363 Q 204+231 T 435 ☑ 435 Q 880+1 T 881 ☑ 881 Q 571+79 T 650 ☑ 650 Q 6+126 T 132 ☑ 132 Q 567+6 T 573 ☑ 573 Q 284+928 T 1212 ☑ 1212 Q 889+9 T 898 ☑ 898 Iteration 22 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0224 - accuracy: 0.9937 - val_loss: 0.0100 - val_accuracy: 0.9980 Q 694+851 T 1545 ☑ 1545 Q 84+582 T 666 ☑ 666 Q 900+476 T 1376 ☑ 1376 Q 661+848 T 1509 ☑ 1509 Q 2+210 T 212 ☑ 212 Q 4+568 T 572 ☑ 572 Q 699+555 T 1254 ☑ 1254 Q 750+64 T 814 ☑ 814 Q 299+938 T 1237 ☑ 1237 Q 213+94 T 307 ☑ 307 Iteration 23 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0285 - accuracy: 0.9919 - val_loss: 0.0769 - val_accuracy: 0.9790 Q 70+650 T 720 ☑ 720 Q 914+8 T 922 ☑ 922 Q 925+53 T 978 ☑ 978 Q 19+49 T 68 ☒ 78 Q 12+940 T 952 ☑ 952 Q 85+879 T 964 ☑ 964 Q 652+461 T 1113 ☑ 1113 Q 223+59 T 282 ☑ 282 Q 361+55 T 416 ☑ 416 Q 940+1 T 941 ☑ 941 Iteration 24 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0101 - accuracy: 0.9979 - val_loss: 0.0218 - val_accuracy: 0.9937 Q 653+77 T 730 ☑ 730 Q 73+155 T 228 ☑ 228 Q 62+355 T 417 ☑ 417 Q 859+916 T 1775 ☑ 1775 Q 201+153 T 354 ☑ 354 Q 469+1 T 470 ☑ 470 Q 52+363 T 415 ☑ 415 Q 22+706 T 728 ☑ 728 Q 58+33 T 91 ☑ 91 Q 371+51 T 422 ☑ 422 Iteration 25 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0174 - accuracy: 0.9952 - val_loss: 0.1332 - val_accuracy: 0.9670 Q 213+94 T 307 ☑ 307 Q 390+7 T 397 ☑ 397 Q 14+498 T 512 ☑ 512 Q 14+312 T 326 ☑ 326 Q 56+653 T 709 ☑ 709 Q 37+28 T 65 ☑ 65 Q 113+70 T 183 ☑ 183 Q 326+398 T 724 ☑ 724 Q 137+8 T 145 ☑ 145 Q 50+19 T 69 ☑ 69 Iteration 26 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0231 - accuracy: 0.9937 - val_loss: 0.0088 - val_accuracy: 0.9983 Q 886+20 T 906 ☑ 906 Q 61+790 T 851 ☑ 851 Q 610+63 T 673 ☑ 673 Q 27+20 T 47 ☑ 47 Q 130+32 T 162 ☑ 162 Q 555+25 T 580 ☑ 580 Q 95+43 T 138 ☑ 138 Q 5+427 T 432 ☑ 432 Q 395+651 T 1046 ☑ 1046 Q 188+19 T 207 ☑ 207 Iteration 27 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0218 - accuracy: 0.9940 - val_loss: 0.0070 - val_accuracy: 0.9987 Q 495+735 T 1230 ☑ 1230 Q 74+607 T 681 ☑ 681 Q 225+56 T 281 ☑ 281 Q 581+589 T 1170 ☑ 1170 Q 37+953 T 990 ☑ 990 Q 17+510 T 527 ☑ 527 Q 621+73 T 694 ☑ 694 Q 54+298 T 352 ☑ 352 Q 636+518 T 1154 ☑ 1154 Q 7+673 T 680 ☑ 680 Iteration 28 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0114 - accuracy: 0.9971 - val_loss: 0.0238 - val_accuracy: 0.9930 Q 67+12 T 79 ☑ 79 Q 109+464 T 573 ☑ 573 Q 4+52 T 56 ☑ 56 Q 907+746 T 1653 ☑ 1653 Q 153+864 T 1017 ☑ 1017 Q 666+77 T 743 ☑ 743 Q 65+777 T 842 ☑ 842 Q 52+60 T 112 ☑ 112 Q 941+692 T 1633 ☑ 1633 Q 931+666 T 1597 ☑ 1597 Iteration 29 1407/1407 [==============================] - 8s 6ms/step - loss: 0.0262 - accuracy: 0.9929 - val_loss: 0.0643 - val_accuracy: 0.9804 Q 128+86 T 214 ☑ 214 Q 20+494 T 514 ☑ 514 Q 34+896 T 930 ☑ 930 Q 372+15 T 387 ☑ 387 Q 466+63 T 529 ☑ 529 Q 327+9 T 336 ☑ 336 Q 458+85 T 543 ☑ 543 Q 134+431 T 565 ☑ 565 Q 807+289 T 1096 ☑ 1096 Q 100+60 T 160 ☑ 160 You'll get to 99+% validation accuracy after ~30 epochs. Text sentiment classification starting from raw text files. Introduction This example shows how to do text classification starting from raw text (as a set of text files on disk). We demonstrate the workflow on the IMDB sentiment classification dataset (unprocessed version). We use the TextVectorization layer for word splitting & indexing. Setup import tensorflow as tf import numpy as np Load the data: IMDB movie review sentiment classification Let's download the data and inspect its structure. !curl -O https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz !tar -xf aclImdb_v1.tar.gz % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 80.2M 100 80.2M 0 0 16.1M 0 0:00:04 0:00:04 --:--:-- 16.4M The aclImdb folder contains a train and test subfolder: !ls aclImdb !ls aclImdb/test !ls aclImdb/train README imdb.vocab imdbEr.txt test train labeledBow.feat neg pos urls_neg.txt urls_pos.txt labeledBow.feat pos unsupBow.feat urls_pos.txt neg unsup urls_neg.txt urls_unsup.txt The aclImdb/train/pos and aclImdb/train/neg folders contain text files, each of which represents one review (either positive or negative): !cat aclImdb/train/pos/6248_7.txt Being an Austrian myself this has been a straight knock in my face. Fortunately I don't live nowhere near the place where this movie takes place but unfortunately it portrays everything that the rest of Austria hates about Viennese people (or people close to that region). And it is very easy to read that this is exactly the directors intention: to let your head sink into your hands and say \"Oh my god, how can THAT be possible!\". No, not with me, the (in my opinion) totally exaggerated uncensored swinger club scene is not necessary, I watch porn, sure, but in this context I was rather disgusted than put in the right context.

This movie tells a story about how misled people who suffer from lack of education or bad company try to survive and live in a world of redundancy and boring horizons. A girl who is treated like a whore by her super-jealous boyfriend (and still keeps coming back), a female teacher who discovers her masochism by putting the life of her super-cruel \"lover\" on the line, an old couple who has an almost mathematical daily cycle (she is the \"official replacement\" of his ex wife), a couple that has just divorced and has the ex husband suffer under the acts of his former wife obviously having a relationship with her masseuse and finally a crazy hitchhiker who asks her drivers the most unusual questions and stretches their nerves by just being super-annoying.

After having seen it you feel almost nothing. You're not even shocked, sad, depressed or feel like doing anything... Maybe that's why I gave it 7 points, it made me react in a way I never reacted before. If that's good or bad is up to you! We are only interested in the pos and neg subfolders, so let's delete the rest: !rm -r aclImdb/train/unsup You can use the utility tf.keras.preprocessing.text_dataset_from_directory to generate a labeled tf.data.Dataset object from a set of text files on disk filed into class-specific folders. Let's use it to generate the training, validation, and test datasets. The validation and training datasets are generated from two subsets of the train directory, with 20% of samples going to the validation dataset and 80% going to the training dataset. Having a validation dataset in addition to the test dataset is useful for tuning hyperparameters, such as the model architecture, for which the test dataset should not be used. Before putting the model out into the real world however, it should be retrained using all available training data (without creating a validation dataset), so its performance is maximized. When using the validation_split & subset arguments, make sure to either specify a random seed, or to pass shuffle=False, so that the validation & training splits you get have no overlap. batch_size = 32 raw_train_ds = tf.keras.preprocessing.text_dataset_from_directory( \"aclImdb/train\", batch_size=batch_size, validation_split=0.2, subset=\"training\", seed=1337, ) raw_val_ds = tf.keras.preprocessing.text_dataset_from_directory( \"aclImdb/train\", batch_size=batch_size, validation_split=0.2, subset=\"validation\", seed=1337, ) raw_test_ds = tf.keras.preprocessing.text_dataset_from_directory( \"aclImdb/test\", batch_size=batch_size ) print(f\"Number of batches in raw_train_ds: {raw_train_ds.cardinality()}\") print(f\"Number of batches in raw_val_ds: {raw_val_ds.cardinality()}\") print(f\"Number of batches in raw_test_ds: {raw_test_ds.cardinality()}\") Found 25000 files belonging to 2 classes. Using 20000 files for training. Found 25000 files belonging to 2 classes. Using 5000 files for validation. Found 25000 files belonging to 2 classes. Number of batches in raw_train_ds: 625 Number of batches in raw_val_ds: 157 Number of batches in raw_test_ds: 782 Let's preview a few samples: # It's important to take a look at your raw data to ensure your normalization # and tokenization will work as expected. We can do that by taking a few # examples from the training set and looking at them. # This is one of the places where eager execution shines: # we can just evaluate these tensors using .numpy() # instead of needing to evaluate them in a Session/Graph context. for text_batch, label_batch in raw_train_ds.take(1): for i in range(5): print(text_batch.numpy()[i]) print(label_batch.numpy()[i]) b'I\\'ve seen tons of science fiction from the 70s; some horrendously bad, and others thought provoking and truly frightening. Soylent Green fits into the latter category. Yes, at times it\'s a little campy, and yes, the furniture is good for a giggle or two, but some of the film seems awfully prescient. Here we have a film, 9 years before Blade Runner, that dares to imagine the future as somthing dark, scary, and nihilistic. Both Charlton Heston and Edward G. Robinson fare far better in this than The Ten Commandments, and Robinson\'s assisted-suicide scene is creepily prescient of Kevorkian and his ilk. Some of the attitudes are dated (can you imagine a filmmaker getting away with the \"women as furniture\" concept in our oh-so-politically-correct-90s?), but it\'s rare to find a film from the Me Decade that actually can make you think. This is one I\'d love to see on the big screen, because even in a widescreen presentation, I don\'t think the overall scope of this film would receive its due. Check it out.' 1 b'First than anything, I\\'m not going to praise I\\xc3\\xb1arritu\\'s short film, even I\\'m Mexican and proud of his success in mainstream Hollywood.

In another hand, I see most of the reviews focuses on their favorite (and not so) short films; but we are forgetting that there is a subtle bottom line that circles the whole compilation, and maybe it will not be so pleasant for American people. (Even if that was not the main purpose of the producers)

What i\'m talking about is that most of the short films does not show the suffering that WASP people went through because the terrorist attack on September 11th, but the suffering of the Other people.

Do you need proofs about what i\'m saying? Look, in the Bosnia short film, the message is: \"You cry because of the people who died in the Towers, but we (The Others = East Europeans) are crying long ago for the crimes committed against our women and nobody pay attention to us like the whole world has done to you\".

Even though the Burkina Fasso story is more in comedy, there is a the same thought: \"You are angry because Osama Bin Laden punched you in an evil way, but we (The Others = Africans) should be more angry, because our people is dying of hunger, poverty and AIDS long time ago, and nobody pay attention to us like the whole world has done to you\".

Look now at the Sean Penn short: The fall of the Twin Towers makes happy to a lonely (and alienated) man. So the message is that the Power and the Greed (symbolized by the Towers) must fall for letting the people see the sun rise and the flowers blossom? It is remarkable that this terrible bottom line has been proposed by an American. There is so much irony in this short film that it is close to be subversive.

Well, the Ken Loach (very know because his anti-capitalism ideology) is much more clearly and shameless in going straight to the point: \"You are angry because your country has been attacked by evil forces, but we (The Others = Latin Americans) suffered at a similar date something worst, and nobody remembers our grief as the whole world has done to you\".

It is like if the creative of this project wanted to say to Americans: \"You see now, America? You are not the only that have become victim of the world violence, you are not alone in your pain and by the way, we (the Others = the Non Americans) have been suffering a lot more than you from long time ago; so, we are in solidarity with you in your pain... and by the way, we are sorry because you have had some taste of your own medicine\" Only the Mexican and the French short films showed some compassion and sympathy for American people; the others are like a slap on the face for the American State, that is not equal to American People.' 1 b'Blood Castle (aka Scream of the Demon Lover, Altar of Blood, Ivanna--the best, but least exploitation cinema-sounding title, and so on) is a very traditional Gothic Romance film. That means that it has big, creepy castles, a headstrong young woman, a mysterious older man, hints of horror and the supernatural, and romance elements in the contemporary sense of that genre term. It also means that it is very deliberately paced, and that the film will work best for horror mavens who are big fans of understatement. If you love films like Robert Wise\'s The Haunting (1963), but you also have a taste for late 1960s/early 1970s Spanish and Italian horror, you may love Blood Castle, as well.

Baron Janos Dalmar (Carlos Quiney) lives in a large castle on the outskirts of a traditional, unspecified European village. The locals fear him because legend has it that whenever he beds a woman, she soon after ends up dead--the consensus is that he sets his ferocious dogs on them. This is quite a problem because the Baron has a very healthy appetite for women. At the beginning of the film, yet another woman has turned up dead and mutilated.

Meanwhile, Dr. Ivanna Rakowsky (Erna Sch\xc3\xbcrer) has appeared in the center of the village, asking to be taken to Baron Dalmar\'s castle. She\'s an out-of-towner who has been hired by the Baron for her expertise in chemistry. Of course, no one wants to go near the castle. Finally, Ivanna finds a shady individual (who becomes even shadier) to take her. Once there, an odd woman who lives in the castle, Olga (Cristiana Galloni), rejects Ivanna and says that she shouldn\'t be there since she\'s a woman. Baron Dalmar vacillates over whether she should stay. She ends up staying, but somewhat reluctantly. The Baron has hired her to try to reverse the effects of severe burns, which the Baron\'s brother, Igor, is suffering from.

Unfortunately, the Baron\'s brother appears to be just a lump of decomposing flesh in a vat of bizarre, blackish liquid. And furthermore, Ivanna is having bizarre, hallucinatory dreams. Just what is going on at the castle? Is the Baron responsible for the crimes? Is he insane?

I wanted to like Blood Castle more than I did. As I mentioned, the film is very deliberate in its pacing, and most of it is very understated. I can go either way on material like that. I don\'t care for The Haunting (yes, I\'m in a very small minority there), but I\'m a big fan of 1960s and 1970s European horror. One of my favorite directors is Mario Bava. I also love Dario Argento\'s work from that period. But occasionally, Blood Castle moved a bit too slow for me at times. There are large chunks that amount to scenes of not very exciting talking alternated with scenes of Ivanna slowly walking the corridors of the castle.

But the atmosphere of the film is decent. Director Jos\xc3\xa9 Luis Merino managed more than passable sets and locations, and they\'re shot fairly well by Emanuele Di Cola. However, Blood Castle feels relatively low budget, and this is a Roger Corman-produced film, after all (which usually means a low-budget, though often surprisingly high quality \"quickie\"). So while there is a hint of the lushness of Bava\'s colors and complex set decoration, everything is much more minimalist. Of course, it doesn\'t help that the Retromedia print I watched looks like a 30-year old photograph that\'s been left out in the sun too long. It appears \"washed out\", with compromised contrast.

Still, Merino and Di Cola occasionally set up fantastic visuals. For example, a scene of Ivanna walking in a darkened hallway that\'s shot from an exaggerated angle, and where an important plot element is revealed through shadows on a wall only. There are also a couple Ingmar Bergmanesque shots, where actors are exquisitely blocked to imply complex relationships, besides just being visually attractive and pulling your eye deep into the frame.

The performances are fairly good, and the women--especially Sch\xc3\xbcrer--are very attractive. Merino exploits this fact by incorporating a decent amount of nudity. Sch\xc3\xbcrer went on to do a number of films that were as much soft corn porn as they were other genres, with English titles such as Sex Life in a Woman\'s Prison (1974), Naked and Lustful (1974), Strip Nude for Your Killer (1975) and Erotic Exploits of a Sexy Seducer (1977). Blood Castle is much tamer, but in addition to the nudity, there are still mild scenes suggesting rape and bondage, and of course the scenes mixing sex and death.

The primary attraction here, though, is probably the story, which is much a slow-burning romance as anything else. The horror elements, the mystery elements, and a somewhat unexpected twist near the end are bonuses, but in the end, Blood Castle is a love story, about a couple overcoming various difficulties and antagonisms (often with physical threats or harms) to be together.' 1 b\"I was talked into watching this movie by a friend who blubbered on about what a cute story this was.

Yuck.

I want my two hours back, as I could have done SO many more productive things with my time...like, for instance, twiddling my thumbs. I see nothing redeeming about this film at all, save for the eye-candy aspect of it...

3/10 (and that's being generous)\" 0 b\"Michelle Rodriguez is the defining actress who could be the charging force for other actresses to look out for. She has the audacity to place herself in a rarely seen tough-girl role very early in her career (and pull it off), which is a feat that should be recognized. Although her later films pigeonhole her to that same role, this film was made for her ruggedness.

Her character is a romanticized student/fighter/lover, struggling to overcome her disenchanted existence in the projects, which is a little overdone in film...but not by a girl. That aspect of this film isn't very original, but the story goes in depth when the heated relationships that this girl has to deal with come to a boil and her primal rage takes over.

I haven't seen an actress take such an aggressive stance in movie-making yet, and I'm glad that she's getting that original twist out there in Hollywood. This film got a 7 from me because of the average story of ghetto youth, but it has such a great actress portraying a rarely-seen role in a minimal budget movie. Great work.\" 1 Prepare the data In particular, we remove
tags. from tensorflow.keras.layers import TextVectorization import string import re # Having looked at our data above, we see that the raw text contains HTML break # tags of the form '
'. These tags will not be removed by the default # standardizer (which doesn't strip HTML). Because of this, we will need to # create a custom standardization function. def custom_standardization(input_data): lowercase = tf.strings.lower(input_data) stripped_html = tf.strings.regex_replace(lowercase, \"
\", \" \") return tf.strings.regex_replace( stripped_html, f\"[{re.escape(string.punctuation)}]\", \"\" ) # Model constants. max_features = 20000 embedding_dim = 128 sequence_length = 500 # Now that we have our custom standardization, we can instantiate our text # vectorization layer. We are using this layer to normalize, split, and map # strings to integers, so we set our 'output_mode' to 'int'. # Note that we're using the default split function, # and the custom standardization defined above. # We also set an explicit maximum sequence length, since the CNNs later in our # model won't support ragged sequences. vectorize_layer = TextVectorization( standardize=custom_standardization, max_tokens=max_features, output_mode=\"int\", output_sequence_length=sequence_length, ) # Now that the vocab layer has been created, call `adapt` on a text-only # dataset to create the vocabulary. You don't have to batch, but for very large # datasets this means you're not keeping spare copies of the dataset in memory. # Let's make a text-only dataset (no labels): text_ds = raw_train_ds.map(lambda x, y: x) # Let's call `adapt`: vectorize_layer.adapt(text_ds) Two options to vectorize the data There are 2 ways we can use our text vectorization layer: Option 1: Make it part of the model, so as to obtain a model that processes raw strings, like this: text_input = tf.keras.Input(shape=(1,), dtype=tf.string, name='text') x = vectorize_layer(text_input) x = layers.Embedding(max_features + 1, embedding_dim)(x) ... Option 2: Apply it to the text dataset to obtain a dataset of word indices, then feed it into a model that expects integer sequences as inputs. An important difference between the two is that option 2 enables you to do asynchronous CPU processing and buffering of your data when training on GPU. So if you're training the model on GPU, you probably want to go with this option to get the best performance. This is what we will do below. If we were to export our model to production, we'd ship a model that accepts raw strings as input, like in the code snippet for option 1 above. This can be done after training. We do this in the last section. def vectorize_text(text, label): text = tf.expand_dims(text, -1) return vectorize_layer(text), label # Vectorize the data. train_ds = raw_train_ds.map(vectorize_text) val_ds = raw_val_ds.map(vectorize_text) test_ds = raw_test_ds.map(vectorize_text) # Do async prefetching / buffering of the data for best performance on GPU. train_ds = train_ds.cache().prefetch(buffer_size=10) val_ds = val_ds.cache().prefetch(buffer_size=10) test_ds = test_ds.cache().prefetch(buffer_size=10) Build a model We choose a simple 1D convnet starting with an Embedding layer. from tensorflow.keras import layers # A integer input for vocab indices. inputs = tf.keras.Input(shape=(None,), dtype=\"int64\") # Next, we add a layer to map those vocab indices into a space of dimensionality # 'embedding_dim'. x = layers.Embedding(max_features, embedding_dim)(inputs) x = layers.Dropout(0.5)(x) # Conv1D + global max pooling x = layers.Conv1D(128, 7, padding=\"valid\", activation=\"relu\", strides=3)(x) x = layers.Conv1D(128, 7, padding=\"valid\", activation=\"relu\", strides=3)(x) x = layers.GlobalMaxPooling1D()(x) # We add a vanilla hidden layer: x = layers.Dense(128, activation=\"relu\")(x) x = layers.Dropout(0.5)(x) # We project onto a single unit output layer, and squash it with a sigmoid: predictions = layers.Dense(1, activation=\"sigmoid\", name=\"predictions\")(x) model = tf.keras.Model(inputs, predictions) # Compile the model with binary crossentropy loss and an adam optimizer. model.compile(loss=\"binary_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) Train the model epochs = 3 # Fit the model using the train and test datasets. model.fit(train_ds, validation_data=val_ds, epochs=epochs) Epoch 1/3 625/625 [==============================] - 46s 73ms/step - loss: 0.5005 - accuracy: 0.7156 - val_loss: 0.3103 - val_accuracy: 0.8696 Epoch 2/3 625/625 [==============================] - 51s 81ms/step - loss: 0.2262 - accuracy: 0.9115 - val_loss: 0.3255 - val_accuracy: 0.8754 Epoch 3/3 625/625 [==============================] - 50s 81ms/step - loss: 0.1142 - accuracy: 0.9574 - val_loss: 0.4157 - val_accuracy: 0.8698 Evaluate the model on the test set model.evaluate(test_ds) 782/782 [==============================] - 14s 18ms/step - loss: 0.4539 - accuracy: 0.8570 [0.45387956500053406, 0.8569999933242798] Make an end-to-end model If you want to obtain a model capable of processing raw strings, you can simply create a new model (using the weights we just trained): # A string input inputs = tf.keras.Input(shape=(1,), dtype=\"string\") # Turn strings into vocab indices indices = vectorize_layer(inputs) # Turn vocab indices into predictions outputs = model(indices) # Our end to end model end_to_end_model = tf.keras.Model(inputs, outputs) end_to_end_model.compile( loss=\"binary_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"] ) # Test it with `raw_test_ds`, which yields raw strings end_to_end_model.evaluate(raw_test_ds) 782/782 [==============================] - 20s 25ms/step - loss: 0.4539 - accuracy: 0.8570 [0.45387890934944153, 0.8569999933242798] Implement a Switch Transformer for text classification. Introduction This example demonstrates the implementation of the Switch Transformer model for text classification. The Switch Transformer replaces the feedforward network (FFN) layer in the standard Transformer with a Mixture of Expert (MoE) routing layer, where each expert operates independently on the tokens in the sequence. This allows increasing the model size without increasing the computation needed to process each example. Note that, for training the Switch Transformer efficiently, data and model parallelism need to be applied, so that expert modules can run simultaneously, each on its own accelerator. While the implementation described in the paper uses the TensorFlow Mesh framework for distributed training, this example presents a simple, non-distributed implementation of the Switch Transformer model for demonstration purposes. Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Download and prepare dataset vocab_size = 20000 # Only consider the top 20k words num_tokens_per_example = 200 # Only consider the first 200 words of each movie review (x_train, y_train), (x_val, y_val) = keras.datasets.imdb.load_data(num_words=vocab_size) print(len(x_train), \"Training sequences\") print(len(x_val), \"Validation sequences\") x_train = keras.preprocessing.sequence.pad_sequences( x_train, maxlen=num_tokens_per_example ) x_val = keras.preprocessing.sequence.pad_sequences(x_val, maxlen=num_tokens_per_example) 25000 Training sequences 25000 Validation sequences Define hyperparameters embed_dim = 32 # Embedding size for each token. num_heads = 2 # Number of attention heads ff_dim = 32 # Hidden layer size in feedforward network. num_experts = 10 # Number of experts used in the Switch Transformer. batch_size = 50 # Batch size. learning_rate = 0.001 # Learning rate. dropout_rate = 0.25 # Dropout rate. num_epochs = 3 # Number of epochs. num_tokens_per_batch = ( batch_size * num_tokens_per_example ) # Total number of tokens per batch. print(f\"Number of tokens per batch: {num_tokens_per_batch}\") Number of tokens per batch: 10000 Implement token & position embedding layer It consists of two seperate embedding layers, one for tokens, one for token index (positions). class TokenAndPositionEmbedding(layers.Layer): def __init__(self, maxlen, vocab_size, embed_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = layers.Embedding(input_dim=vocab_size, output_dim=embed_dim) self.pos_emb = layers.Embedding(input_dim=maxlen, output_dim=embed_dim) def call(self, x): maxlen = tf.shape(x)[-1] positions = tf.range(start=0, limit=maxlen, delta=1) positions = self.pos_emb(positions) x = self.token_emb(x) return x + positions Implement the feedforward network This is used as the Mixture of Experts in the Switch Transformer. def create_feedforward_network(ff_dim, name=None): return keras.Sequential( [layers.Dense(ff_dim, activation=\"relu\"), layers.Dense(ff_dim)], name=name ) Implement the load-balanced loss This is an auxiliary loss to encourage a balanced load across experts. def load_balanced_loss(router_probs, expert_mask): # router_probs [tokens_per_batch, num_experts] is the probability assigned for # each expert per token. expert_mask [tokens_per_batch, num_experts] contains # the expert with the highest router probability in one−hot format. num_experts = tf.shape(expert_mask)[-1] # Get the fraction of tokens routed to each expert. # density is a vector of length num experts that sums to 1. density = tf.reduce_mean(expert_mask, axis=0) # Get fraction of probability mass assigned to each expert from the router # across all tokens. density_proxy is a vector of length num experts that sums to 1. density_proxy = tf.reduce_mean(router_probs, axis=0) # Want both vectors to have uniform allocation (1/num experts) across all # num_expert elements. The two vectors will be pushed towards uniform allocation # when the dot product is minimized. loss = tf.reduce_mean(density_proxy * density) * tf.cast( (num_experts ** 2), tf.dtypes.float32 ) return loss Implement the router as a layer class Router(layers.Layer): def __init__(self, num_experts, expert_capacity): self.num_experts = num_experts self.route = layers.Dense(units=num_experts) self.expert_capacity = expert_capacity super(Router, self).__init__() def call(self, inputs, training=False): # inputs shape: [tokens_per_batch, embed_dim] # router_logits shape: [tokens_per_batch, num_experts] router_logits = self.route(inputs) if training: # Add noise for exploration across experts. router_logits += tf.random.uniform( shape=router_logits.shape, minval=0.9, maxval=1.1 ) # Probabilities for each token of what expert it should be sent to. router_probs = keras.activations.softmax(router_logits, axis=-1) # Get the top−1 expert for each token. expert_gate is the top−1 probability # from the router for each token. expert_index is what expert each token # is going to be routed to. expert_gate, expert_index = tf.math.top_k(router_probs, k=1) # expert_mask shape: [tokens_per_batch, num_experts] expert_mask = tf.one_hot(expert_index, depth=self.num_experts) # Compute load balancing loss. aux_loss = load_balanced_loss(router_probs, expert_mask) self.add_loss(aux_loss) # Experts have a fixed capacity, ensure we do not exceed it. Construct # the batch indices, to each expert, with position in expert make sure that # not more that expert capacity examples can be routed to each expert. position_in_expert = tf.cast( tf.math.cumsum(expert_mask, axis=0) * expert_mask, tf.dtypes.int32 ) # Keep only tokens that fit within expert capacity. expert_mask *= tf.cast( tf.math.less( tf.cast(position_in_expert, tf.dtypes.int32), self.expert_capacity ), tf.dtypes.float32, ) expert_mask_flat = tf.reduce_sum(expert_mask, axis=-1) # Mask out the experts that have overflowed the expert capacity. expert_gate *= expert_mask_flat # Combine expert outputs and scaling with router probability. # combine_tensor shape: [tokens_per_batch, num_experts, expert_capacity] combined_tensor = tf.expand_dims( expert_gate * expert_mask_flat * tf.squeeze(tf.one_hot(expert_index, depth=self.num_experts), 1), -1, ) * tf.squeeze(tf.one_hot(position_in_expert, depth=self.expert_capacity), 1) # Create binary dispatch_tensor [tokens_per_batch, num_experts, expert_capacity] # that is 1 if the token gets routed to the corresponding expert. dispatch_tensor = tf.cast(combined_tensor, tf.dtypes.float32) return dispatch_tensor, combined_tensor Implement a Switch layer class Switch(layers.Layer): def __init__(self, num_experts, embed_dim, num_tokens_per_batch, capacity_factor=1): self.num_experts = num_experts self.embed_dim = embed_dim self.experts = [ create_feedforward_network(embed_dim) for _ in range(num_experts) ] self.expert_capacity = num_tokens_per_batch // self.num_experts self.router = Router(self.num_experts, self.expert_capacity) super(Switch, self).__init__() def call(self, inputs): batch_size = tf.shape(inputs)[0] num_tokens_per_example = tf.shape(inputs)[1] # inputs shape: [num_tokens_per_batch, embed_dim] inputs = tf.reshape(inputs, [num_tokens_per_batch, self.embed_dim]) # dispatch_tensor shape: [expert_capacity, num_experts, tokens_per_batch] # combine_tensor shape: [tokens_per_batch, num_experts, expert_capacity] dispatch_tensor, combine_tensor = self.router(inputs) # expert_inputs shape: [num_experts, expert_capacity, embed_dim] expert_inputs = tf.einsum(\"ab,acd->cdb\", inputs, dispatch_tensor) expert_inputs = tf.reshape( expert_inputs, [self.num_experts, self.expert_capacity, self.embed_dim] ) # Dispatch to experts expert_input_list = tf.unstack(expert_inputs, axis=0) expert_output_list = [ self.experts[idx](expert_input) for idx, expert_input in enumerate(expert_input_list) ] # expert_outputs shape: [expert_capacity, num_experts, embed_dim] expert_outputs = tf.stack(expert_output_list, axis=1) # expert_outputs_combined shape: [tokens_per_batch, embed_dim] expert_outputs_combined = tf.einsum( \"abc,xba->xc\", expert_outputs, combine_tensor ) # output shape: [batch_size, num_tokens_per_example, embed_dim] outputs = tf.reshape( expert_outputs_combined, [batch_size, num_tokens_per_example, self.embed_dim], ) return outputs Implement a Transformer block layer class TransformerBlock(layers.Layer): def __init__(self, embed_dim, num_heads, ffn, dropout_rate=0.1): super(TransformerBlock, self).__init__() self.att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim) # The ffn can be either a standard feedforward network or a switch # layer with a Mixture of Experts. self.ffn = ffn self.layernorm1 = layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = layers.LayerNormalization(epsilon=1e-6) self.dropout1 = layers.Dropout(dropout_rate) self.dropout2 = layers.Dropout(dropout_rate) def call(self, inputs, training): attn_output = self.att(inputs, inputs) attn_output = self.dropout1(attn_output, training=training) out1 = self.layernorm1(inputs + attn_output) ffn_output = self.ffn(out1) ffn_output = self.dropout2(ffn_output, training=training) return self.layernorm2(out1 + ffn_output) Implement the classifier The TransformerBlock layer outputs one vector for each time step of our input sequence. Here, we take the mean across all time steps and use a feedforward network on top of it to classify text. def create_classifier(): switch = Switch(num_experts, embed_dim, num_tokens_per_batch) transformer_block = TransformerBlock(ff_dim, num_heads, switch) inputs = layers.Input(shape=(num_tokens_per_example,)) embedding_layer = TokenAndPositionEmbedding( num_tokens_per_example, vocab_size, embed_dim ) x = embedding_layer(inputs) x = transformer_block(x) x = layers.GlobalAveragePooling1D()(x) x = layers.Dropout(dropout_rate)(x) x = layers.Dense(ff_dim, activation=\"relu\")(x) x = layers.Dropout(dropout_rate)(x) outputs = layers.Dense(2, activation=\"softmax\")(x) classifier = keras.Model(inputs=inputs, outputs=outputs) return classifier Train and evaluate the model def run_experiment(classifier): classifier.compile( optimizer=keras.optimizers.Adam(learning_rate), loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"], ) history = classifier.fit( x_train, y_train, batch_size=batch_size, epochs=num_epochs, validation_data=(x_val, y_val), ) return history classifier = create_classifier() run_experiment(classifier) Epoch 1/3 500/500 [==============================] - 575s 1s/step - loss: 1.5311 - accuracy: 0.7151 - val_loss: 1.2915 - val_accuracy: 0.8772 Epoch 2/3 500/500 [==============================] - 575s 1s/step - loss: 1.1971 - accuracy: 0.9262 - val_loss: 1.3073 - val_accuracy: 0.8708 Epoch 3/3 500/500 [==============================] - 624s 1s/step - loss: 1.1284 - accuracy: 0.9563 - val_loss: 1.3547 - val_accuracy: 0.8637 Conclusion Compared to the standard Transformer architecture, the Switch Transformer can have a much larger number of parameters, leading to increased model capacity, while maintaining a reasonable computational cost. Implement a Transformer block as a Keras layer and use it for text classification. Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Implement a Transformer block as a layer class TransformerBlock(layers.Layer): def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1): super(TransformerBlock, self).__init__() self.att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim) self.ffn = keras.Sequential( [layers.Dense(ff_dim, activation=\"relu\"), layers.Dense(embed_dim),] ) self.layernorm1 = layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = layers.LayerNormalization(epsilon=1e-6) self.dropout1 = layers.Dropout(rate) self.dropout2 = layers.Dropout(rate) def call(self, inputs, training): attn_output = self.att(inputs, inputs) attn_output = self.dropout1(attn_output, training=training) out1 = self.layernorm1(inputs + attn_output) ffn_output = self.ffn(out1) ffn_output = self.dropout2(ffn_output, training=training) return self.layernorm2(out1 + ffn_output) Implement embedding layer Two seperate embedding layers, one for tokens, one for token index (positions). class TokenAndPositionEmbedding(layers.Layer): def __init__(self, maxlen, vocab_size, embed_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = layers.Embedding(input_dim=vocab_size, output_dim=embed_dim) self.pos_emb = layers.Embedding(input_dim=maxlen, output_dim=embed_dim) def call(self, x): maxlen = tf.shape(x)[-1] positions = tf.range(start=0, limit=maxlen, delta=1) positions = self.pos_emb(positions) x = self.token_emb(x) return x + positions Download and prepare dataset vocab_size = 20000 # Only consider the top 20k words maxlen = 200 # Only consider the first 200 words of each movie review (x_train, y_train), (x_val, y_val) = keras.datasets.imdb.load_data(num_words=vocab_size) print(len(x_train), \"Training sequences\") print(len(x_val), \"Validation sequences\") x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen) x_val = keras.preprocessing.sequence.pad_sequences(x_val, maxlen=maxlen) Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz 17465344/17464789 [==============================] - 0s 0us/step :6: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray /usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/datasets/imdb.py:159: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray x_train, y_train = np.array(xs[:idx]), np.array(labels[:idx]) /usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/datasets/imdb.py:160: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray x_test, y_test = np.array(xs[idx:]), np.array(labels[idx:]) 25000 Training sequences 25000 Validation sequences Create classifier model using transformer layer Transformer layer outputs one vector for each time step of our input sequence. Here, we take the mean across all time steps and use a feed forward network on top of it to classify text. embed_dim = 32 # Embedding size for each token num_heads = 2 # Number of attention heads ff_dim = 32 # Hidden layer size in feed forward network inside transformer inputs = layers.Input(shape=(maxlen,)) embedding_layer = TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) x = embedding_layer(inputs) transformer_block = TransformerBlock(embed_dim, num_heads, ff_dim) x = transformer_block(x) x = layers.GlobalAveragePooling1D()(x) x = layers.Dropout(0.1)(x) x = layers.Dense(20, activation=\"relu\")(x) x = layers.Dropout(0.1)(x) outputs = layers.Dense(2, activation=\"softmax\")(x) model = keras.Model(inputs=inputs, outputs=outputs) Train and Evaluate model.compile(optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"]) history = model.fit( x_train, y_train, batch_size=32, epochs=2, validation_data=(x_val, y_val) ) Epoch 1/2 782/782 [==============================] - 15s 18ms/step - loss: 0.5112 - accuracy: 0.7070 - val_loss: 0.3598 - val_accuracy: 0.8444 Epoch 2/2 782/782 [==============================] - 13s 17ms/step - loss: 0.1942 - accuracy: 0.9297 - val_loss: 0.2977 - val_accuracy: 0.8745 Fine tune pretrained BERT from HuggingFace Transformers on SQuAD. Introduction This demonstration uses SQuAD (Stanford Question-Answering Dataset). In SQuAD, an input consists of a question, and a paragraph for context. The goal is to find the span of text in the paragraph that answers the question. We evaluate our performance on this data with the \"Exact Match\" metric, which measures the percentage of predictions that exactly match any one of the ground-truth answers. We fine-tune a BERT model to perform this task as follows: Feed the context and the question as inputs to BERT. Take two vectors S and T with dimensions equal to that of hidden states in BERT. Compute the probability of each token being the start and end of the answer span. The probability of a token being the start of the answer is given by a dot product between S and the representation of the token in the last layer of BERT, followed by a softmax over all tokens. The probability of a token being the end of the answer is computed similarly with the vector T. Fine-tune BERT and learn S and T along the way. References: BERT SQuAD Setup import os import re import json import string import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tokenizers import BertWordPieceTokenizer from transformers import BertTokenizer, TFBertModel, BertConfig max_len = 384 configuration = BertConfig() # default parameters and configuration for BERT Set-up BERT tokenizer # Save the slow pretrained tokenizer slow_tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\") save_path = \"bert_base_uncased/\" if not os.path.exists(save_path): os.makedirs(save_path) slow_tokenizer.save_pretrained(save_path) # Load the fast tokenizer from saved file tokenizer = BertWordPieceTokenizer(\"bert_base_uncased/vocab.txt\", lowercase=True) Load the data train_data_url = \"https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v1.1.json\" train_path = keras.utils.get_file(\"train.json\", train_data_url) eval_data_url = \"https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v1.1.json\" eval_path = keras.utils.get_file(\"eval.json\", eval_data_url) Preprocess the data Go through the JSON file and store every record as a SquadExample object. Go through each SquadExample and create x_train, y_train, x_eval, y_eval. class SquadExample: def __init__(self, question, context, start_char_idx, answer_text, all_answers): self.question = question self.context = context self.start_char_idx = start_char_idx self.answer_text = answer_text self.all_answers = all_answers self.skip = False def preprocess(self): context = self.context question = self.question answer_text = self.answer_text start_char_idx = self.start_char_idx # Clean context, answer and question context = \" \".join(str(context).split()) question = \" \".join(str(question).split()) answer = \" \".join(str(answer_text).split()) # Find end character index of answer in context end_char_idx = start_char_idx + len(answer) if end_char_idx >= len(context): self.skip = True return # Mark the character indexes in context that are in answer is_char_in_ans = [0] * len(context) for idx in range(start_char_idx, end_char_idx): is_char_in_ans[idx] = 1 # Tokenize context tokenized_context = tokenizer.encode(context) # Find tokens that were created from answer characters ans_token_idx = [] for idx, (start, end) in enumerate(tokenized_context.offsets): if sum(is_char_in_ans[start:end]) > 0: ans_token_idx.append(idx) if len(ans_token_idx) == 0: self.skip = True return # Find start and end token index for tokens from answer start_token_idx = ans_token_idx[0] end_token_idx = ans_token_idx[-1] # Tokenize question tokenized_question = tokenizer.encode(question) # Create inputs input_ids = tokenized_context.ids + tokenized_question.ids[1:] token_type_ids = [0] * len(tokenized_context.ids) + [1] * len( tokenized_question.ids[1:] ) attention_mask = [1] * len(input_ids) # Pad and create attention masks. # Skip if truncation is needed padding_length = max_len - len(input_ids) if padding_length > 0: # pad input_ids = input_ids + ([0] * padding_length) attention_mask = attention_mask + ([0] * padding_length) token_type_ids = token_type_ids + ([0] * padding_length) elif padding_length < 0: # skip self.skip = True return self.input_ids = input_ids self.token_type_ids = token_type_ids self.attention_mask = attention_mask self.start_token_idx = start_token_idx self.end_token_idx = end_token_idx self.context_token_to_char = tokenized_context.offsets with open(train_path) as f: raw_train_data = json.load(f) with open(eval_path) as f: raw_eval_data = json.load(f) def create_squad_examples(raw_data): squad_examples = [] for item in raw_data[\"data\"]: for para in item[\"paragraphs\"]: context = para[\"context\"] for qa in para[\"qas\"]: question = qa[\"question\"] answer_text = qa[\"answers\"][0][\"text\"] all_answers = [_[\"text\"] for _ in qa[\"answers\"]] start_char_idx = qa[\"answers\"][0][\"answer_start\"] squad_eg = SquadExample( question, context, start_char_idx, answer_text, all_answers ) squad_eg.preprocess() squad_examples.append(squad_eg) return squad_examples def create_inputs_targets(squad_examples): dataset_dict = { \"input_ids\": [], \"token_type_ids\": [], \"attention_mask\": [], \"start_token_idx\": [], \"end_token_idx\": [], } for item in squad_examples: if item.skip == False: for key in dataset_dict: dataset_dict[key].append(getattr(item, key)) for key in dataset_dict: dataset_dict[key] = np.array(dataset_dict[key]) x = [ dataset_dict[\"input_ids\"], dataset_dict[\"token_type_ids\"], dataset_dict[\"attention_mask\"], ] y = [dataset_dict[\"start_token_idx\"], dataset_dict[\"end_token_idx\"]] return x, y train_squad_examples = create_squad_examples(raw_train_data) x_train, y_train = create_inputs_targets(train_squad_examples) print(f\"{len(train_squad_examples)} training points created.\") eval_squad_examples = create_squad_examples(raw_eval_data) x_eval, y_eval = create_inputs_targets(eval_squad_examples) print(f\"{len(eval_squad_examples)} evaluation points created.\") 87599 training points created. 10570 evaluation points created. Create the Question-Answering Model using BERT and Functional API def create_model(): ## BERT encoder encoder = TFBertModel.from_pretrained(\"bert-base-uncased\") ## QA Model input_ids = layers.Input(shape=(max_len,), dtype=tf.int32) token_type_ids = layers.Input(shape=(max_len,), dtype=tf.int32) attention_mask = layers.Input(shape=(max_len,), dtype=tf.int32) embedding = encoder( input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask )[0] start_logits = layers.Dense(1, name=\"start_logit\", use_bias=False)(embedding) start_logits = layers.Flatten()(start_logits) end_logits = layers.Dense(1, name=\"end_logit\", use_bias=False)(embedding) end_logits = layers.Flatten()(end_logits) start_probs = layers.Activation(keras.activations.softmax)(start_logits) end_probs = layers.Activation(keras.activations.softmax)(end_logits) model = keras.Model( inputs=[input_ids, token_type_ids, attention_mask], outputs=[start_probs, end_probs], ) loss = keras.losses.SparseCategoricalCrossentropy(from_logits=False) optimizer = keras.optimizers.Adam(lr=5e-5) model.compile(optimizer=optimizer, loss=[loss, loss]) return model This code should preferably be run on Google Colab TPU runtime. With Colab TPUs, each epoch will take 5-6 minutes. use_tpu = True if use_tpu: # Create distribution strategy tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect() strategy = tf.distribute.TPUStrategy(tpu) # Create model with strategy.scope(): model = create_model() else: model = create_model() model.summary() INFO:absl:Entering into master device scope: /job:worker/replica:0/task:0/device:CPU:0 INFO:tensorflow:Initializing the TPU system: grpc://10.48.159.170:8470 INFO:tensorflow:Clearing out eager caches INFO:tensorflow:Finished initializing TPU system. INFO:tensorflow:Found TPU system: INFO:tensorflow:*** Num TPU Cores: 8 INFO:tensorflow:*** Num TPU Workers: 1 INFO:tensorflow:*** Num TPU Cores Per Worker: 8 Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 384)] 0 __________________________________________________________________________________________________ input_3 (InputLayer) [(None, 384)] 0 __________________________________________________________________________________________________ input_2 (InputLayer) [(None, 384)] 0 __________________________________________________________________________________________________ tf_bert_model (TFBertModel) ((None, 384, 768), ( 109482240 input_1[0][0] __________________________________________________________________________________________________ start_logit (Dense) (None, 384, 1) 768 tf_bert_model[0][0] __________________________________________________________________________________________________ end_logit (Dense) (None, 384, 1) 768 tf_bert_model[0][0] __________________________________________________________________________________________________ flatten (Flatten) (None, 384) 0 start_logit[0][0] __________________________________________________________________________________________________ flatten_1 (Flatten) (None, 384) 0 end_logit[0][0] __________________________________________________________________________________________________ activation_7 (Activation) (None, 384) 0 flatten[0][0] __________________________________________________________________________________________________ activation_8 (Activation) (None, 384) 0 flatten_1[0][0] ================================================================================================== Total params: 109,483,776 Trainable params: 109,483,776 Non-trainable params: 0 __________________________________________________________________________________________________ Create evaluation Callback This callback will compute the exact match score using the validation data after every epoch. def normalize_text(text): text = text.lower() # Remove punctuations exclude = set(string.punctuation) text = \"\".join(ch for ch in text if ch not in exclude) # Remove articles regex = re.compile(r\"\b(a|an|the)\b\", re.UNICODE) text = re.sub(regex, \" \", text) # Remove extra white space text = \" \".join(text.split()) return text class ExactMatch(keras.callbacks.Callback): \"\"\" Each `SquadExample` object contains the character level offsets for each token in its input paragraph. We use them to get back the span of text corresponding to the tokens between our predicted start and end tokens. All the ground-truth answers are also present in each `SquadExample` object. We calculate the percentage of data points where the span of text obtained from model predictions matches one of the ground-truth answers. \"\"\" def __init__(self, x_eval, y_eval): self.x_eval = x_eval self.y_eval = y_eval def on_epoch_end(self, epoch, logs=None): pred_start, pred_end = self.model.predict(self.x_eval) count = 0 eval_examples_no_skip = [_ for _ in eval_squad_examples if _.skip == False] for idx, (start, end) in enumerate(zip(pred_start, pred_end)): squad_eg = eval_examples_no_skip[idx] offsets = squad_eg.context_token_to_char start = np.argmax(start) end = np.argmax(end) if start >= len(offsets): continue pred_char_start = offsets[start][0] if end < len(offsets): pred_char_end = offsets[end][1] pred_ans = squad_eg.context[pred_char_start:pred_char_end] else: pred_ans = squad_eg.context[pred_char_start:] normalized_pred_ans = normalize_text(pred_ans) normalized_true_ans = [normalize_text(_) for _ in squad_eg.all_answers] if normalized_pred_ans in normalized_true_ans: count += 1 acc = count / len(self.y_eval[0]) print(f\"\nepoch={epoch+1}, exact match score={acc:.2f}\") Train and Evaluate exact_match_callback = ExactMatch(x_eval, y_eval) model.fit( x_train, y_train, epochs=1, # For demonstration, 3 epochs are recommended verbose=2, batch_size=64, callbacks=[exact_match_callback], ) epoch=1, exact match score=0.78 1346/1346 - 350s - activation_7_loss: 1.3488 - loss: 2.5905 - activation_8_loss: 1.2417 FNet transformer for text generation in Keras. Introduction The original transformer implementation (Vaswani et al., 2017) was one of the major breakthroughs in Natural Language Processing, giving rise to important architectures such BERT and GPT. However, the drawback of these architectures is that the self-attention mechanism they use is computationally expensive. The FNet architecture proposes to replace this self-attention attention with a leaner mechanism: a Fourier transformation-based linear mixer for input tokens. The FNet model was able to achieve 92-97% of BERT's accuracy while training 80% faster on GPUs and almost 70% faster on TPUs. This type of design provides an efficient and small model size, leading to faster inference times. In this example, we will implement and train this architecture on the Cornell Movie Dialog corpus to show the applicability of this model to text generation. Imports import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import os import re # Defining hyperparameters VOCAB_SIZE = 8192 MAX_SAMPLES = 50000 BUFFER_SIZE = 20000 MAX_LENGTH = 40 EMBED_DIM = 256 LATENT_DIM = 512 NUM_HEADS = 8 BATCH_SIZE = 64 Loading data We will be using the Cornell Dialog Corpus. We will parse the movie conversations into questions and answers sets. path_to_zip = keras.utils.get_file( \"cornell_movie_dialogs.zip\", origin=\"http://www.cs.cornell.edu/~cristian/data/cornell_movie_dialogs_corpus.zip\", extract=True, ) path_to_dataset = os.path.join( os.path.dirname(path_to_zip), \"cornell movie-dialogs corpus\" ) path_to_movie_lines = os.path.join(path_to_dataset, \"movie_lines.txt\") path_to_movie_conversations = os.path.join(path_to_dataset, \"movie_conversations.txt\") def load_conversations(): # Helper function for loading the conversation splits id2line = {} with open(path_to_movie_lines, errors=\"ignore\") as file: lines = file.readlines() for line in lines: parts = line.replace(\"\n\", \"\").split(\" +++$+++ \") id2line[parts[0]] = parts[4] inputs, outputs = [], [] with open(path_to_movie_conversations, \"r\") as file: lines = file.readlines() for line in lines: parts = line.replace(\"\n\", \"\").split(\" +++$+++ \") # get conversation in a list of line ID conversation = [line[1:-1] for line in parts[3][1:-1].split(\", \")] for i in range(len(conversation) - 1): inputs.append(id2line[conversation[i]]) outputs.append(id2line[conversation[i + 1]]) if len(inputs) >= MAX_SAMPLES: return inputs, outputs return inputs, outputs questions, answers = load_conversations() # Splitting training and validation sets train_dataset = tf.data.Dataset.from_tensor_slices((questions[:40000], answers[:40000])) val_dataset = tf.data.Dataset.from_tensor_slices((questions[40000:], answers[40000:])) Downloading data from http://www.cs.cornell.edu/~cristian/data/cornell_movie_dialogs_corpus.zip 9920512/9916637 [==============================] - 0s 0us/step 9928704/9916637 [==============================] - 0s 0us/step Preprocessing and Tokenization def preprocess_text(sentence): sentence = tf.strings.lower(sentence) # Adding a space between the punctuation and the last word to allow better tokenization sentence = tf.strings.regex_replace(sentence, r\"([?.!,])\", r\" \\1 \") # Replacing multiple continuous spaces with a single space sentence = tf.strings.regex_replace(sentence, r\"\\s\\s+\", \" \") # Replacing non english words with spaces sentence = tf.strings.regex_replace(sentence, r\"[^a-z?.!,]+\", \" \") sentence = tf.strings.strip(sentence) sentence = tf.strings.join([\"[start]\", sentence, \"[end]\"], separator=\" \") return sentence vectorizer = layers.TextVectorization( VOCAB_SIZE, standardize=preprocess_text, output_mode=\"int\", output_sequence_length=MAX_LENGTH, ) # We will adapt the vectorizer to both the questions and answers # This dataset is batched to parallelize and speed up the process vectorizer.adapt(tf.data.Dataset.from_tensor_slices((questions + answers)).batch(128)) Tokenizing and padding sentences using TextVectorization def vectorize_text(inputs, outputs): inputs, outputs = vectorizer(inputs), vectorizer(outputs) # One extra padding token to the right to match the output shape outputs = tf.pad(outputs, [[0, 1]]) return ( {\"encoder_inputs\": inputs, \"decoder_inputs\": outputs[:-1]}, {\"outputs\": outputs[1:]}, ) train_dataset = train_dataset.map(vectorize_text, num_parallel_calls=tf.data.AUTOTUNE) val_dataset = val_dataset.map(vectorize_text, num_parallel_calls=tf.data.AUTOTUNE) train_dataset = ( train_dataset.cache() .shuffle(BUFFER_SIZE) .batch(BATCH_SIZE) .prefetch(tf.data.AUTOTUNE) ) val_dataset = val_dataset.cache().batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE) Creating the FNet Encoder The FNet paper proposes a replacement for the standard attention mechanism used by the Transformer architecture (Vaswani et al., 2017). Architecture The outputs of the FFT layer are complex numbers. To avoid dealing with complex layers, only the real part (the magnitude) is extracted. The dense layers that follow the Fourier transformation act as convolutions applied on the frequency domain. class FNetEncoder(layers.Layer): def __init__(self, embed_dim, dense_dim, **kwargs): super(FNetEncoder, self).__init__(**kwargs) self.embed_dim = embed_dim self.dense_dim = dense_dim self.dense_proj = keras.Sequential( [ layers.Dense(dense_dim, activation=\"relu\"), layers.Dense(embed_dim), ] ) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() def call(self, inputs): # Casting the inputs to complex64 inp_complex = tf.cast(inputs, tf.complex64) # Projecting the inputs to the frequency domain using FFT2D and # extracting the real part of the output fft = tf.math.real(tf.signal.fft2d(inp_complex)) proj_input = self.layernorm_1(inputs + fft) proj_output = self.dense_proj(proj_input) return self.layernorm_2(proj_input + proj_output) Creating the Decoder The decoder architecture remains the same as the one proposed by (Vaswani et al., 2017) in the original transformer architecture, consisting of an embedding, positional encoding, two masked multihead attention layers and finally the dense output layers. The architecture that follows is taken from Deep Learning with Python, second edition, chapter 11. class PositionalEmbedding(layers.Layer): def __init__(self, sequence_length, vocab_size, embed_dim, **kwargs): super(PositionalEmbedding, self).__init__(**kwargs) self.token_embeddings = layers.Embedding( input_dim=vocab_size, output_dim=embed_dim ) self.position_embeddings = layers.Embedding( input_dim=sequence_length, output_dim=embed_dim ) self.sequence_length = sequence_length self.vocab_size = vocab_size self.embed_dim = embed_dim def call(self, inputs): length = tf.shape(inputs)[-1] positions = tf.range(start=0, limit=length, delta=1) embedded_tokens = self.token_embeddings(inputs) embedded_positions = self.position_embeddings(positions) return embedded_tokens + embedded_positions def compute_mask(self, inputs, mask=None): return tf.math.not_equal(inputs, 0) class FNetDecoder(layers.Layer): def __init__(self, embed_dim, latent_dim, num_heads, **kwargs): super(FNetDecoder, self).__init__(**kwargs) self.embed_dim = embed_dim self.latent_dim = latent_dim self.num_heads = num_heads self.attention_1 = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim ) self.attention_2 = layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim ) self.dense_proj = keras.Sequential( [ layers.Dense(latent_dim, activation=\"relu\"), layers.Dense(embed_dim), ] ) self.layernorm_1 = layers.LayerNormalization() self.layernorm_2 = layers.LayerNormalization() self.layernorm_3 = layers.LayerNormalization() self.supports_masking = True def call(self, inputs, encoder_outputs, mask=None): causal_mask = self.get_causal_attention_mask(inputs) if mask is not None: padding_mask = tf.cast(mask[:, tf.newaxis, :], dtype=\"int32\") padding_mask = tf.minimum(padding_mask, causal_mask) attention_output_1 = self.attention_1( query=inputs, value=inputs, key=inputs, attention_mask=causal_mask ) out_1 = self.layernorm_1(inputs + attention_output_1) attention_output_2 = self.attention_2( query=out_1, value=encoder_outputs, key=encoder_outputs, attention_mask=padding_mask, ) out_2 = self.layernorm_2(out_1 + attention_output_2) proj_output = self.dense_proj(out_2) return self.layernorm_3(out_2 + proj_output) def get_causal_attention_mask(self, inputs): input_shape = tf.shape(inputs) batch_size, sequence_length = input_shape[0], input_shape[1] i = tf.range(sequence_length)[:, tf.newaxis] j = tf.range(sequence_length) mask = tf.cast(i >= j, dtype=\"int32\") mask = tf.reshape(mask, (1, input_shape[1], input_shape[1])) mult = tf.concat( [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)], axis=0, ) return tf.tile(mask, mult) def create_model(): encoder_inputs = keras.Input(shape=(None,), dtype=\"int32\", name=\"encoder_inputs\") x = PositionalEmbedding(MAX_LENGTH, VOCAB_SIZE, EMBED_DIM)(encoder_inputs) encoder_outputs = FNetEncoder(EMBED_DIM, LATENT_DIM)(x) encoder = keras.Model(encoder_inputs, encoder_outputs) decoder_inputs = keras.Input(shape=(None,), dtype=\"int32\", name=\"decoder_inputs\") encoded_seq_inputs = keras.Input( shape=(None, EMBED_DIM), name=\"decoder_state_inputs\" ) x = PositionalEmbedding(MAX_LENGTH, VOCAB_SIZE, EMBED_DIM)(decoder_inputs) x = FNetDecoder(EMBED_DIM, LATENT_DIM, NUM_HEADS)(x, encoded_seq_inputs) x = layers.Dropout(0.5)(x) decoder_outputs = layers.Dense(VOCAB_SIZE, activation=\"softmax\")(x) decoder = keras.Model( [decoder_inputs, encoded_seq_inputs], decoder_outputs, name=\"outputs\" ) decoder_outputs = decoder([decoder_inputs, encoder_outputs]) fnet = keras.Model([encoder_inputs, decoder_inputs], decoder_outputs, name=\"fnet\") return fnet Creating and Training the model fnet = create_model() fnet.compile(\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"]) Here, the epochs parameter is set to a single epoch, but in practice the model will take around 20-30 epochs of training to start outputting comprehensible sentences. Although accuracy is not a good measure for this task, we will use it just to get a hint of the improvement of the network. fnet.fit(train_dataset, epochs=1, validation_data=val_dataset) 625/625 [==============================] - 96s 133ms/step - loss: 1.3036 - accuracy: 0.4354 - val_loss: 0.7964 - val_accuracy: 0.6374 Performing inference VOCAB = vectorizer.get_vocabulary() def decode_sentence(input_sentence): # Mapping the input sentence to tokens and adding start and end tokens tokenized_input_sentence = vectorizer( tf.constant(\"[start] \" + preprocess_text(input_sentence) + \" [end]\") ) # Initializing the initial sentence consisting of only the start token. tokenized_target_sentence = tf.expand_dims(VOCAB.index(\"[start]\"), 0) decoded_sentence = \"\" for i in range(MAX_LENGTH): # Get the predictions predictions = fnet.predict( { \"encoder_inputs\": tf.expand_dims(tokenized_input_sentence, 0), \"decoder_inputs\": tf.expand_dims( tf.pad( tokenized_target_sentence, [[0, MAX_LENGTH - tf.shape(tokenized_target_sentence)[0]]], ), 0, ), } ) # Calculating the token with maximum probability and getting the corresponding word sampled_token_index = tf.argmax(predictions[0, i, :]) sampled_token = VOCAB[sampled_token_index.numpy()] # If sampled token is the end token then stop generating and return the sentence if tf.equal(sampled_token_index, VOCAB.index(\"[end]\")): break decoded_sentence += sampled_token + \" \" tokenized_target_sentence = tf.concat( [tokenized_target_sentence, [sampled_token_index]], 0 ) return decoded_sentence decode_sentence(\"Where have you been all this time?\") 'i m sorry .' Conclusion This example shows how to train and perform inference using the FNet model. For getting insight into the architecture or for further reading, you can refer to: FNet: Mixing Tokens with Fourier Transforms (Lee-Thorp et al., 2021) Attention Is All You Need (Vaswani et al., 2017) Thanks to François Chollet for his Keras example on English-to-Spanish translation with a sequence-to-sequence Transformer from which the decoder implementation was extracted. Text classification on the Newsgroup20 dataset using pre-trained GloVe word embeddings. Setup import numpy as np import tensorflow as tf from tensorflow import keras Introduction In this example, we show how to train a text classification model that uses pre-trained word embeddings. We'll work with the Newsgroup20 dataset, a set of 20,000 message board messages belonging to 20 different topic categories. For the pre-trained word embeddings, we'll use GloVe embeddings. Download the Newsgroup20 data data_path = keras.utils.get_file( \"news20.tar.gz\", \"http://www.cs.cmu.edu/afs/cs.cmu.edu/project/theo-20/www/data/news20.tar.gz\", untar=True, ) Let's take a look at the data import os import pathlib data_dir = pathlib.Path(data_path).parent / \"20_newsgroup\" dirnames = os.listdir(data_dir) print(\"Number of directories:\", len(dirnames)) print(\"Directory names:\", dirnames) fnames = os.listdir(data_dir / \"comp.graphics\") print(\"Number of files in comp.graphics:\", len(fnames)) print(\"Some example filenames:\", fnames[:5]) Number of directories: 20 Directory names: ['talk.politics.mideast', 'rec.autos', 'comp.sys.mac.hardware', 'alt.atheism', 'rec.sport.baseball', 'comp.os.ms-windows.misc', 'rec.sport.hockey', 'sci.crypt', 'sci.med', 'talk.politics.misc', 'rec.motorcycles', 'comp.windows.x', 'comp.graphics', 'comp.sys.ibm.pc.hardware', 'sci.electronics', 'talk.politics.guns', 'sci.space', 'soc.religion.christian', 'misc.forsale', 'talk.religion.misc'] Number of files in comp.graphics: 1000 Some example filenames: ['38254', '38402', '38630', '38865', '38891'] Here's a example of what one file contains: print(open(data_dir / \"comp.graphics\" / \"38987\").read()) Newsgroups: comp.graphics Path: cantaloupe.srv.cs.cmu.edu!das-news.harvard.edu!noc.near.net!howland.reston.ans.net!agate!dog.ee.lbl.gov!network.ucsd.edu!usc!rpi!nason110.its.rpi.edu!mabusj From: mabusj@nason110.its.rpi.edu (Jasen M. Mabus) Subject: Looking for Brain in CAD Message-ID: Nntp-Posting-Host: nason110.its.rpi.edu Reply-To: mabusj@rpi.edu Organization: Rensselaer Polytechnic Institute, Troy, NY. Date: Thu, 29 Apr 1993 23:27:20 GMT Lines: 7 Jasen Mabus RPI student I am looking for a hman brain in any CAD (.dxf,.cad,.iges,.cgm,etc.) or picture (.gif,.jpg,.ras,etc.) format for an animation demonstration. If any has or knows of a location please reply by e-mail to mabusj@rpi.edu. Thank you in advance, Jasen Mabus As you can see, there are header lines that are leaking the file's category, either explicitly (the first line is literally the category name), or implicitly, e.g. via the Organization filed. Let's get rid of the headers: samples = [] labels = [] class_names = [] class_index = 0 for dirname in sorted(os.listdir(data_dir)): class_names.append(dirname) dirpath = data_dir / dirname fnames = os.listdir(dirpath) print(\"Processing %s, %d files found\" % (dirname, len(fnames))) for fname in fnames: fpath = dirpath / fname f = open(fpath, encoding=\"latin-1\") content = f.read() lines = content.split(\"\n\") lines = lines[10:] content = \"\n\".join(lines) samples.append(content) labels.append(class_index) class_index += 1 print(\"Classes:\", class_names) print(\"Number of samples:\", len(samples)) Processing alt.atheism, 1000 files found Processing comp.graphics, 1000 files found Processing comp.os.ms-windows.misc, 1000 files found Processing comp.sys.ibm.pc.hardware, 1000 files found Processing comp.sys.mac.hardware, 1000 files found Processing comp.windows.x, 1000 files found Processing misc.forsale, 1000 files found Processing rec.autos, 1000 files found Processing rec.motorcycles, 1000 files found Processing rec.sport.baseball, 1000 files found Processing rec.sport.hockey, 1000 files found Processing sci.crypt, 1000 files found Processing sci.electronics, 1000 files found Processing sci.med, 1000 files found Processing sci.space, 1000 files found Processing soc.religion.christian, 997 files found Processing talk.politics.guns, 1000 files found Processing talk.politics.mideast, 1000 files found Processing talk.politics.misc, 1000 files found Processing talk.religion.misc, 1000 files found Classes: ['alt.atheism', 'comp.graphics', 'comp.os.ms-windows.misc', 'comp.sys.ibm.pc.hardware', 'comp.sys.mac.hardware', 'comp.windows.x', 'misc.forsale', 'rec.autos', 'rec.motorcycles', 'rec.sport.baseball', 'rec.sport.hockey', 'sci.crypt', 'sci.electronics', 'sci.med', 'sci.space', 'soc.religion.christian', 'talk.politics.guns', 'talk.politics.mideast', 'talk.politics.misc', 'talk.religion.misc'] Number of samples: 19997 There's actually one category that doesn't have the expected number of files, but the difference is small enough that the problem remains a balanced classification problem. Shuffle and split the data into training & validation sets # Shuffle the data seed = 1337 rng = np.random.RandomState(seed) rng.shuffle(samples) rng = np.random.RandomState(seed) rng.shuffle(labels) # Extract a training & validation split validation_split = 0.2 num_validation_samples = int(validation_split * len(samples)) train_samples = samples[:-num_validation_samples] val_samples = samples[-num_validation_samples:] train_labels = labels[:-num_validation_samples] val_labels = labels[-num_validation_samples:] Create a vocabulary index Let's use the TextVectorization to index the vocabulary found in the dataset. Later, we'll use the same layer instance to vectorize the samples. Our layer will only consider the top 20,000 words, and will truncate or pad sequences to be actually 200 tokens long. from tensorflow.keras.layers import TextVectorization vectorizer = TextVectorization(max_tokens=20000, output_sequence_length=200) text_ds = tf.data.Dataset.from_tensor_slices(train_samples).batch(128) vectorizer.adapt(text_ds) You can retrieve the computed vocabulary used via vectorizer.get_vocabulary(). Let's print the top 5 words: vectorizer.get_vocabulary()[:5] ['', '[UNK]', 'the', 'to', 'of'] Let's vectorize a test sentence: output = vectorizer([[\"the cat sat on the mat\"]]) output.numpy()[0, :6] array([ 2, 3697, 1686, 15, 2, 5943]) As you can see, \"the\" gets represented as \"2\". Why not 0, given that \"the\" was the first word in the vocabulary? That's because index 0 is reserved for padding and index 1 is reserved for \"out of vocabulary\" tokens. Here's a dict mapping words to their indices: voc = vectorizer.get_vocabulary() word_index = dict(zip(voc, range(len(voc)))) As you can see, we obtain the same encoding as above for our test sentence: test = [\"the\", \"cat\", \"sat\", \"on\", \"the\", \"mat\"] [word_index[w] for w in test] [2, 3697, 1686, 15, 2, 5943] Load pre-trained word embeddings Let's download pre-trained GloVe embeddings (a 822M zip file). You'll need to run the following commands: !wget http://nlp.stanford.edu/data/glove.6B.zip !unzip -q glove.6B.zip The archive contains text-encoded vectors of various sizes: 50-dimensional, 100-dimensional, 200-dimensional, 300-dimensional. We'll use the 100D ones. Let's make a dict mapping words (strings) to their NumPy vector representation: path_to_glove_file = os.path.join( os.path.expanduser(\"~\"), \".keras/datasets/glove.6B.100d.txt\" ) embeddings_index = {} with open(path_to_glove_file) as f: for line in f: word, coefs = line.split(maxsplit=1) coefs = np.fromstring(coefs, \"f\", sep=\" \") embeddings_index[word] = coefs print(\"Found %s word vectors.\" % len(embeddings_index)) Found 400000 word vectors. Now, let's prepare a corresponding embedding matrix that we can use in a Keras Embedding layer. It's a simple NumPy matrix where entry at index i is the pre-trained vector for the word of index i in our vectorizer's vocabulary. num_tokens = len(voc) + 2 embedding_dim = 100 hits = 0 misses = 0 # Prepare embedding matrix embedding_matrix = np.zeros((num_tokens, embedding_dim)) for word, i in word_index.items(): embedding_vector = embeddings_index.get(word) if embedding_vector is not None: # Words not found in embedding index will be all-zeros. # This includes the representation for \"padding\" and \"OOV\" embedding_matrix[i] = embedding_vector hits += 1 else: misses += 1 print(\"Converted %d words (%d misses)\" % (hits, misses)) Converted 17999 words (2001 misses) Next, we load the pre-trained word embeddings matrix into an Embedding layer. Note that we set trainable=False so as to keep the embeddings fixed (we don't want to update them during training). from tensorflow.keras.layers import Embedding embedding_layer = Embedding( num_tokens, embedding_dim, embeddings_initializer=keras.initializers.Constant(embedding_matrix), trainable=False, ) Build the model A simple 1D convnet with global max pooling and a classifier at the end. from tensorflow.keras import layers int_sequences_input = keras.Input(shape=(None,), dtype=\"int64\") embedded_sequences = embedding_layer(int_sequences_input) x = layers.Conv1D(128, 5, activation=\"relu\")(embedded_sequences) x = layers.MaxPooling1D(5)(x) x = layers.Conv1D(128, 5, activation=\"relu\")(x) x = layers.MaxPooling1D(5)(x) x = layers.Conv1D(128, 5, activation=\"relu\")(x) x = layers.GlobalMaxPooling1D()(x) x = layers.Dense(128, activation=\"relu\")(x) x = layers.Dropout(0.5)(x) preds = layers.Dense(len(class_names), activation=\"softmax\")(x) model = keras.Model(int_sequences_input, preds) model.summary() Model: \"model\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, None)] 0 _________________________________________________________________ embedding (Embedding) (None, None, 100) 2000200 _________________________________________________________________ conv1d (Conv1D) (None, None, 128) 64128 _________________________________________________________________ max_pooling1d (MaxPooling1D) (None, None, 128) 0 _________________________________________________________________ conv1d_1 (Conv1D) (None, None, 128) 82048 _________________________________________________________________ max_pooling1d_1 (MaxPooling1 (None, None, 128) 0 _________________________________________________________________ conv1d_2 (Conv1D) (None, None, 128) 82048 _________________________________________________________________ global_max_pooling1d (Global (None, 128) 0 _________________________________________________________________ dense (Dense) (None, 128) 16512 _________________________________________________________________ dropout (Dropout) (None, 128) 0 _________________________________________________________________ dense_1 (Dense) (None, 20) 2580 ================================================================= Total params: 2,247,516 Trainable params: 247,316 Non-trainable params: 2,000,200 _________________________________________________________________ Train the model First, convert our list-of-strings data to NumPy arrays of integer indices. The arrays are right-padded. x_train = vectorizer(np.array([[s] for s in train_samples])).numpy() x_val = vectorizer(np.array([[s] for s in val_samples])).numpy() y_train = np.array(train_labels) y_val = np.array(val_labels) We use categorical crossentropy as our loss since we're doing softmax classification. Moreover, we use sparse_categorical_crossentropy since our labels are integers. model.compile( loss=\"sparse_categorical_crossentropy\", optimizer=\"rmsprop\", metrics=[\"acc\"] ) model.fit(x_train, y_train, batch_size=128, epochs=20, validation_data=(x_val, y_val)) Epoch 1/20 125/125 [==============================] - 8s 57ms/step - loss: 2.8766 - acc: 0.0945 - val_loss: 2.0770 - val_acc: 0.2956 Epoch 2/20 125/125 [==============================] - 7s 58ms/step - loss: 2.0792 - acc: 0.2887 - val_loss: 1.6626 - val_acc: 0.4076 Epoch 3/20 125/125 [==============================] - 7s 60ms/step - loss: 1.5632 - acc: 0.4527 - val_loss: 1.3000 - val_acc: 0.5609 Epoch 4/20 125/125 [==============================] - 8s 60ms/step - loss: 1.2945 - acc: 0.5612 - val_loss: 1.2282 - val_acc: 0.5944 Epoch 5/20 125/125 [==============================] - 8s 61ms/step - loss: 1.1137 - acc: 0.6209 - val_loss: 1.0695 - val_acc: 0.6409 Epoch 6/20 125/125 [==============================] - 8s 61ms/step - loss: 0.9556 - acc: 0.6718 - val_loss: 1.1743 - val_acc: 0.6124 Epoch 7/20 125/125 [==============================] - 8s 61ms/step - loss: 0.8235 - acc: 0.7172 - val_loss: 1.0126 - val_acc: 0.6602 Epoch 8/20 125/125 [==============================] - 8s 65ms/step - loss: 0.7268 - acc: 0.7475 - val_loss: 1.0608 - val_acc: 0.6632 Epoch 9/20 125/125 [==============================] - 8s 63ms/step - loss: 0.6441 - acc: 0.7759 - val_loss: 1.0606 - val_acc: 0.6664 Epoch 10/20 125/125 [==============================] - 8s 63ms/step - loss: 0.5409 - acc: 0.8120 - val_loss: 1.0380 - val_acc: 0.6884 Epoch 11/20 125/125 [==============================] - 8s 65ms/step - loss: 0.4846 - acc: 0.8273 - val_loss: 1.1073 - val_acc: 0.6729 Epoch 12/20 125/125 [==============================] - 8s 62ms/step - loss: 0.4173 - acc: 0.8553 - val_loss: 1.1256 - val_acc: 0.6864 Epoch 13/20 125/125 [==============================] - 8s 63ms/step - loss: 0.3419 - acc: 0.8808 - val_loss: 1.1576 - val_acc: 0.6979 Epoch 14/20 125/125 [==============================] - 8s 68ms/step - loss: 0.2869 - acc: 0.9053 - val_loss: 1.1381 - val_acc: 0.6974 Epoch 15/20 125/125 [==============================] - 8s 67ms/step - loss: 0.2617 - acc: 0.9118 - val_loss: 1.3850 - val_acc: 0.6747 Epoch 16/20 125/125 [==============================] - 8s 67ms/step - loss: 0.2543 - acc: 0.9152 - val_loss: 1.3119 - val_acc: 0.6972 Epoch 17/20 125/125 [==============================] - 8s 66ms/step - loss: 0.2109 - acc: 0.9267 - val_loss: 1.3145 - val_acc: 0.6954 Epoch 18/20 125/125 [==============================] - 8s 64ms/step - loss: 0.1939 - acc: 0.9364 - val_loss: 1.4054 - val_acc: 0.7009 Epoch 19/20 125/125 [==============================] - 8s 67ms/step - loss: 0.1873 - acc: 0.9379 - val_loss: 1.7441 - val_acc: 0.6667 Epoch 20/20 125/125 [==============================] - 9s 70ms/step - loss: 0.1762 - acc: 0.9420 - val_loss: 1.5269 - val_acc: 0.6927 Export an end-to-end model Now, we may want to export a Model object that takes as input a string of arbitrary length, rather than a sequence of indices. It would make the model much more portable, since you wouldn't have to worry about the input preprocessing pipeline. Our vectorizer is actually a Keras layer, so it's simple: string_input = keras.Input(shape=(1,), dtype=\"string\") x = vectorizer(string_input) preds = model(x) end_to_end_model = keras.Model(string_input, preds) probabilities = end_to_end_model.predict( [[\"this message is about computer graphics and 3D modeling\"]] ) class_names[np.argmax(probabilities[0])] 'comp.graphics' Demonstration of how to train a Keras model that approximates a SVM. Introduction This example demonstrates how to train a Keras model that approximates a Support Vector Machine (SVM). The key idea is to stack a RandomFourierFeatures layer with a linear layer. The RandomFourierFeatures layer can be used to \"kernelize\" linear models by applying a non-linear transformation to the input features and then training a linear model on top of the transformed features. Depending on the loss function of the linear model, the composition of this layer and the linear model results to models that are equivalent (up to approximation) to kernel SVMs (for hinge loss), kernel logistic regression (for logistic loss), kernel linear regression (for MSE loss), etc. In our case, we approximate SVM using a hinge loss. Setup from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.layers.experimental import RandomFourierFeatures Build the model model = keras.Sequential( [ keras.Input(shape=(784,)), RandomFourierFeatures( output_dim=4096, scale=10.0, kernel_initializer=\"gaussian\" ), layers.Dense(units=10), ] ) model.compile( optimizer=keras.optimizers.Adam(learning_rate=1e-3), loss=keras.losses.hinge, metrics=[keras.metrics.CategoricalAccuracy(name=\"acc\")], ) Prepare the data # Load MNIST (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() # Preprocess the data by flattening & scaling it x_train = x_train.reshape(-1, 784).astype(\"float32\") / 255 x_test = x_test.reshape(-1, 784).astype(\"float32\") / 255 # Categorical (one hot) encoding of the labels y_train = keras.utils.to_categorical(y_train) y_test = keras.utils.to_categorical(y_test) Train the model model.fit(x_train, y_train, epochs=20, batch_size=128, validation_split=0.2) Epoch 1/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0829 - acc: 0.8681 - val_loss: 0.0432 - val_acc: 0.9358 Epoch 2/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0423 - acc: 0.9364 - val_loss: 0.0364 - val_acc: 0.9471 Epoch 3/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0340 - acc: 0.9502 - val_loss: 0.0360 - val_acc: 0.9488 Epoch 4/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0292 - acc: 0.9572 - val_loss: 0.0286 - val_acc: 0.9582 Epoch 5/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0251 - acc: 0.9637 - val_loss: 0.0261 - val_acc: 0.9643 Epoch 6/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0231 - acc: 0.9684 - val_loss: 0.0259 - val_acc: 0.9639 Epoch 7/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0215 - acc: 0.9710 - val_loss: 0.0247 - val_acc: 0.9662 Epoch 8/20 375/375 [==============================] - 2s 7ms/step - loss: 0.0197 - acc: 0.9740 - val_loss: 0.0263 - val_acc: 0.9629 Epoch 9/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0190 - acc: 0.9749 - val_loss: 0.0222 - val_acc: 0.9704 Epoch 10/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0177 - acc: 0.9767 - val_loss: 0.0224 - val_acc: 0.9689 Epoch 11/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0168 - acc: 0.9781 - val_loss: 0.0231 - val_acc: 0.9661 Epoch 12/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0158 - acc: 0.9804 - val_loss: 0.0232 - val_acc: 0.9688 Epoch 13/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0153 - acc: 0.9814 - val_loss: 0.0227 - val_acc: 0.9682 Epoch 14/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0140 - acc: 0.9829 - val_loss: 0.0228 - val_acc: 0.9678 Epoch 15/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0143 - acc: 0.9820 - val_loss: 0.0230 - val_acc: 0.9676 Epoch 16/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0134 - acc: 0.9840 - val_loss: 0.0246 - val_acc: 0.9675 Epoch 17/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0127 - acc: 0.9853 - val_loss: 0.0224 - val_acc: 0.9697 Epoch 18/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0124 - acc: 0.9855 - val_loss: 0.0248 - val_acc: 0.9659 Epoch 19/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0117 - acc: 0.9867 - val_loss: 0.0207 - val_acc: 0.9722 Epoch 20/20 375/375 [==============================] - 2s 6ms/step - loss: 0.0113 - acc: 0.9870 - val_loss: 0.0205 - val_acc: 0.9724 I can't say that it works well or that it is indeed a good idea, but you can probably get decent results by tuning your hyperparameters. You can use this setup to add a \"SVM layer\" on top of a deep learning model, and train the whole model end-to-end. Converting data to the TFRecord format. Introduction The TFRecord format is a simple format for storing a sequence of binary records. Converting your data into TFRecord has many advantages, such as: More efficient storage: the TFRecord data can take up less space than the original data; it can also be partitioned into multiple files. Fast I/O: the TFRecord format can be read with parallel I/O operations, which is useful for TPUs or multiple hosts. Self-contained files: the TFRecord data can be read from a single source—for example, the COCO2017 dataset originally stores data in two folders (\"images\" and \"annotations\"). An important use case of the TFRecord data format is training on TPUs. First, TPUs are fast enough to benefit from optimized I/O operations. In addition, TPUs require data to be stored remotely (e.g. on Google Cloud Storage) and using the TFRecord format makes it easier to load the data without batch-downloading. Performance using the TFRecord format can be further improved if you also use it with the tf.data API. In this example you will learn how to convert data of different types (image, text, and numeric) into TFRecord. Reference TFRecord and tf.train.Example Dependencies import os import json import pprint import tensorflow as tf import matplotlib.pyplot as plt Download the COCO2017 dataset We will be using the COCO2017 dataset, because it has many different types of features, including images, floating point data, and lists. It will serve as a good example of how to encode different features into the TFRecord format. This dataset has two sets of fields: images and annotation meta-data. The images are a collection of JPG files and the meta-data are stored in a JSON file which, according to the official site, contains the following properties: id: int, image_id: int, category_id: int, segmentation: RLE or [polygon], object segmentation mask bbox: [x,y,width,height], object bounding box coordinates area: float, area of the bounding box iscrowd: 0 or 1, is single object or a collection root_dir = \"datasets\" tfrecords_dir = \"tfrecords\" images_dir = os.path.join(root_dir, \"val2017\") annotations_dir = os.path.join(root_dir, \"annotations\") annotation_file = os.path.join(annotations_dir, \"instances_val2017.json\") images_url = \"http://images.cocodataset.org/zips/val2017.zip\" annotations_url = ( \"http://images.cocodataset.org/annotations/annotations_trainval2017.zip\" ) # Download image files if not os.path.exists(images_dir): image_zip = tf.keras.utils.get_file( \"images.zip\", cache_dir=os.path.abspath(\".\"), origin=images_url, extract=True, ) os.remove(image_zip) # Download caption annotation files if not os.path.exists(annotations_dir): annotation_zip = tf.keras.utils.get_file( \"captions.zip\", cache_dir=os.path.abspath(\".\"), origin=annotations_url, extract=True, ) os.remove(annotation_zip) print(\"The COCO dataset has been downloaded and extracted successfully.\") with open(annotation_file, \"r\") as f: annotations = json.load(f)[\"annotations\"] print(f\"Number of images: {len(annotations)}\") Downloading data from http://images.cocodataset.org/zips/val2017.zip 815587328/815585330 [==============================] - 990s 1us/step Downloading data from http://images.cocodataset.org/annotations/annotations_trainval2017.zip 172441600/252907541 [===================>..........] - ETA: 1:35 Contents of the COCO2017 dataset pprint.pprint(annotations[60]) {'area': 367.89710000000014, 'bbox': [265.67, 222.31, 26.48, 14.71], 'category_id': 72, 'id': 34096, 'image_id': 525083, 'iscrowd': 0, 'segmentation': [[267.51, 222.31, 292.15, 222.31, 291.05, 237.02, 265.67, 237.02]]} Parameters num_samples is the number of data samples on each TFRecord file. num_tfrecords is total number of TFRecords that we will create. num_samples = 4096 num_tfrecords = len(annotations) // num_samples if len(annotations) % num_samples: num_tfrecords += 1 # add one record if there are any remaining samples if not os.path.exists(tfrecords_dir): os.makedirs(tfrecords_dir) # creating TFRecords output folder Define TFRecords helper functions def image_feature(value): \"\"\"Returns a bytes_list from a string / byte.\"\"\" return tf.train.Feature( bytes_list=tf.train.BytesList(value=[tf.io.encode_jpeg(value).numpy()]) ) def bytes_feature(value): \"\"\"Returns a bytes_list from a string / byte.\"\"\" return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value.encode()])) def float_feature(value): \"\"\"Returns a float_list from a float / double.\"\"\" return tf.train.Feature(float_list=tf.train.FloatList(value=[value])) def int64_feature(value): \"\"\"Returns an int64_list from a bool / enum / int / uint.\"\"\" return tf.train.Feature(int64_list=tf.train.Int64List(value=[value])) def float_feature_list(value): \"\"\"Returns a list of float_list from a float / double.\"\"\" return tf.train.Feature(float_list=tf.train.FloatList(value=value)) def create_example(image, path, example): feature = { \"image\": image_feature(image), \"path\": bytes_feature(path), \"area\": float_feature(example[\"area\"]), \"bbox\": float_feature_list(example[\"bbox\"]), \"category_id\": int64_feature(example[\"category_id\"]), \"id\": int64_feature(example[\"id\"]), \"image_id\": int64_feature(example[\"image_id\"]), } return tf.train.Example(features=tf.train.Features(feature=feature)) def parse_tfrecord_fn(example): feature_description = { \"image\": tf.io.FixedLenFeature([], tf.string), \"path\": tf.io.FixedLenFeature([], tf.string), \"area\": tf.io.FixedLenFeature([], tf.float32), \"bbox\": tf.io.VarLenFeature(tf.float32), \"category_id\": tf.io.FixedLenFeature([], tf.int64), \"id\": tf.io.FixedLenFeature([], tf.int64), \"image_id\": tf.io.FixedLenFeature([], tf.int64), } example = tf.io.parse_single_example(example, feature_description) example[\"image\"] = tf.io.decode_jpeg(example[\"image\"], channels=3) example[\"bbox\"] = tf.sparse.to_dense(example[\"bbox\"]) return example Generate data in the TFRecord format Let's generate the COCO2017 data in the TFRecord format. The format will be file_{number}.tfrec (this is optional, but including the number sequences in the file names can make counting easier). for tfrec_num in range(num_tfrecords): samples = annotations[(tfrec_num * num_samples) : ((tfrec_num + 1) * num_samples)] with tf.io.TFRecordWriter( tfrecords_dir + \"/file_%.2i-%i.tfrec\" % (tfrec_num, len(samples)) ) as writer: for sample in samples: image_path = f\"{images_dir}/{sample['image_id']:012d}.jpg\" image = tf.io.decode_jpeg(tf.io.read_file(image_path)) example = create_example(image, image_path, sample) writer.write(example.SerializeToString()) Explore one sample from the generated TFRecord raw_dataset = tf.data.TFRecordDataset(f\"{tfrecords_dir}/file_00-{num_samples}.tfrec\") parsed_dataset = raw_dataset.map(parse_tfrecord_fn) for features in parsed_dataset.take(1): for key in features.keys(): if key != \"image\": print(f\"{key}: {features[key]}\") print(f\"Image shape: {features['image'].shape}\") plt.figure(figsize=(7, 7)) plt.imshow(features[\"image\"].numpy()) plt.show() bbox: [473.07 395.93 38.65 28.67] area: 702.1057739257812 category_id: 18 id: 1768 image_id: 289343 path: b'datasets/val2017/000000289343.jpg' Image shape: (640, 529, 3) png Train a simple model using the generated TFRecords Another advantage of TFRecord is that you are able to add many features to it and later use only a few of them, in this case, we are going to use only image and category_id. Define dataset helper functions def prepare_sample(features): image = tf.image.resize(features[\"image\"], size=(224, 224)) return image, features[\"category_id\"] def get_dataset(filenames, batch_size): dataset = ( tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE) .map(parse_tfrecord_fn, num_parallel_calls=AUTOTUNE) .map(prepare_sample, num_parallel_calls=AUTOTUNE) .shuffle(batch_size * 10) .batch(batch_size) .prefetch(AUTOTUNE) ) return dataset train_filenames = tf.io.gfile.glob(f\"{tfrecords_dir}/*.tfrec\") batch_size = 32 epochs = 1 steps_per_epoch = 50 AUTOTUNE = tf.data.AUTOTUNE input_tensor = tf.keras.layers.Input(shape=(224, 224, 3), name=\"image\") model = tf.keras.applications.EfficientNetB0( input_tensor=input_tensor, weights=None, classes=91 ) model.compile( optimizer=tf.keras.optimizers.Adam(), loss=tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()], ) model.fit( x=get_dataset(train_filenames, batch_size), epochs=epochs, steps_per_epoch=steps_per_epoch, verbose=1, ) 50/50 [==============================] - 258s 5s/step - loss: 3.9857 - sparse_categorical_accuracy: 0.2375 Conclusion This example demonstrates that instead of reading images and annotations from different sources you can have your data coming from a single source thanks to TFRecord. This process can make storing and reading data simpler and more efficient. For more information, you can go to the TFRecord and tf.train.Example tutorial. The example shows how to implement custom convolution layers using the Conv.convolution_op() API. Introduction You may sometimes need to implement custom versions of convolution layers like Conv1D and Conv2D. Keras enables you do this without implementing the entire layer from scratch: you can reuse most of the base convolution layer and just customize the convolution op itself via the convolution_op() method. This method was introduced in Keras 2.7. So before using the convolution_op() API, ensure that you are running Keras version 2.7.0 or greater. import tensorflow.keras as keras print(keras.__version__) 2.7.0 A Simple StandardizedConv2D implementation There are two ways to use the Conv.convolution_op() API. The first way is to override the convolution_op() method on a convolution layer subclass. Using this approach, we can quickly implement a StandardizedConv2D as shown below. import tensorflow as tf import tensorflow.keras as keras import keras.layers as layers import numpy as np class StandardizedConv2DWithOverride(layers.Conv2D): def convolution_op(self, inputs, kernel): mean, var = tf.nn.moments(kernel, axes=[0, 1, 2], keepdims=True) return tf.nn.conv2d( inputs, (kernel - mean) / tf.sqrt(var + 1e-10), padding=\"VALID\", strides=list(self.strides), name=self.__class__.__name__, ) The other way to use the Conv.convolution_op() API is to directly call the convolution_op() method from the call() method of a convolution layer subclass. A comparable class implemented using this approach is shown below. class StandardizedConv2DWithCall(layers.Conv2D): def call(self, inputs): mean, var = tf.nn.moments(self.kernel, axes=[0, 1, 2], keepdims=True) result = self.convolution_op( inputs, (self.kernel - mean) / tf.sqrt(var + 1e-10) ) if self.use_bias: result = result + self.bias return result Example Usage Both of these layers work as drop-in replacements for Conv2D. The following demonstration performs classification on the MNIST dataset. # Model / data parameters num_classes = 10 input_shape = (28, 28, 1) # the data, split between train and test sets (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() # Scale images to the [0, 1] range x_train = x_train.astype(\"float32\") / 255 x_test = x_test.astype(\"float32\") / 255 # Make sure images have shape (28, 28, 1) x_train = np.expand_dims(x_train, -1) x_test = np.expand_dims(x_test, -1) print(\"x_train shape:\", x_train.shape) print(x_train.shape[0], \"train samples\") print(x_test.shape[0], \"test samples\") # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) model = keras.Sequential( [ keras.layers.InputLayer(input_shape=input_shape), StandardizedConv2DWithCall(32, kernel_size=(3, 3), activation=\"relu\"), layers.MaxPooling2D(pool_size=(2, 2)), StandardizedConv2DWithOverride(64, kernel_size=(3, 3), activation=\"relu\"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Flatten(), layers.Dropout(0.5), layers.Dense(num_classes, activation=\"softmax\"), ] ) model.summary() batch_size = 128 epochs = 5 model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) model.fit(x_train, y_train, batch_size=batch_size, epochs=5, validation_split=0.1) x_train shape: (60000, 28, 28, 1) 60000 train samples 10000 test samples Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= standardized_conv2d_with_ca (None, 26, 26, 32) 320 ll (StandardizedConv2DWithC all) max_pooling2d (MaxPooling2D (None, 13, 13, 32) 0 ) standardized_conv2d_with_ov (None, 11, 11, 64) 18496 erride (StandardizedConv2DW ithOverride) max_pooling2d_1 (MaxPooling (None, 5, 5, 64) 0 2D) flatten (Flatten) (None, 1600) 0 dropout (Dropout) (None, 1600) 0 dense (Dense) (None, 10) 16010 ================================================================= Total params: 34,826 Trainable params: 34,826 Non-trainable params: 0 _________________________________________________________________ Epoch 1/5 422/422 [==============================] - 7s 15ms/step - loss: 1.8435 - accuracy: 0.8415 - val_loss: 0.1177 - val_accuracy: 0.9660 Epoch 2/5 422/422 [==============================] - 6s 14ms/step - loss: 0.2460 - accuracy: 0.9338 - val_loss: 0.0727 - val_accuracy: 0.9772 Epoch 3/5 422/422 [==============================] - 6s 14ms/step - loss: 0.1600 - accuracy: 0.9541 - val_loss: 0.0537 - val_accuracy: 0.9862 Epoch 4/5 422/422 [==============================] - 6s 14ms/step - loss: 0.1264 - accuracy: 0.9633 - val_loss: 0.0509 - val_accuracy: 0.9845 Epoch 5/5 422/422 [==============================] - 6s 14ms/step - loss: 0.1090 - accuracy: 0.9679 - val_loss: 0.0457 - val_accuracy: 0.9872 Conclusion The Conv.convolution_op() API provides an easy and readable way to implement custom convolution layers. A StandardizedConvolution implementation using the API is quite terse, consisting of only four lines of code. Demonstration of the 'endpoint layer' pattern (layer that handles loss management). Setup import tensorflow as tf from tensorflow import keras import numpy as np Usage of endpoint layers in the Functional API An \"endpoint layer\" has access to the model's targets, and creates arbitrary losses and metrics using add_loss and add_metric. This enables you to define losses and metrics that don't match the usual signature fn(y_true, y_pred, sample_weight=None). Note that you could have separate metrics for training and eval with this pattern. class LogisticEndpoint(keras.layers.Layer): def __init__(self, name=None): super(LogisticEndpoint, self).__init__(name=name) self.loss_fn = keras.losses.BinaryCrossentropy(from_logits=True) self.accuracy_fn = keras.metrics.BinaryAccuracy(name=\"accuracy\") def call(self, logits, targets=None, sample_weight=None): if targets is not None: # Compute the training-time loss value and add it # to the layer using `self.add_loss()`. loss = self.loss_fn(targets, logits, sample_weight) self.add_loss(loss) # Log the accuracy as a metric (we could log arbitrary metrics, # including different metrics for training and inference. self.add_metric(self.accuracy_fn(targets, logits, sample_weight)) # Return the inference-time prediction tensor (for `.predict()`). return tf.nn.softmax(logits) inputs = keras.Input((764,), name=\"inputs\") logits = keras.layers.Dense(1)(inputs) targets = keras.Input((1,), name=\"targets\") sample_weight = keras.Input((1,), name=\"sample_weight\") preds = LogisticEndpoint()(logits, targets, sample_weight) model = keras.Model([inputs, targets, sample_weight], preds) data = { \"inputs\": np.random.random((1000, 764)), \"targets\": np.random.random((1000, 1)), \"sample_weight\": np.random.random((1000, 1)), } model.compile(keras.optimizers.Adam(1e-3)) model.fit(data, epochs=2) Epoch 1/2 32/32 [==============================] - 0s 898us/step - loss: 0.3674 - accuracy: 0.0000e+00 Epoch 2/2 32/32 [==============================] - 0s 847us/step - loss: 0.3563 - accuracy: 0.0000e+00 Exporting an inference-only model Simply don't include targets in the model. The weights stay the same. inputs = keras.Input((764,), name=\"inputs\") logits = keras.layers.Dense(1)(inputs) preds = LogisticEndpoint()(logits, targets=None, sample_weight=None) inference_model = keras.Model(inputs, preds) inference_model.set_weights(model.get_weights()) preds = inference_model.predict(np.random.random((1000, 764))) Usage of loss endpoint layers in subclassed models class LogReg(keras.Model): def __init__(self): super(LogReg, self).__init__() self.dense = keras.layers.Dense(1) self.logistic_endpoint = LogisticEndpoint() def call(self, inputs): # Note that all inputs should be in the first argument # since we want to be able to call `model.fit(inputs)`. logits = self.dense(inputs[\"inputs\"]) preds = self.logistic_endpoint( logits=logits, targets=inputs[\"targets\"], sample_weight=inputs[\"sample_weight\"], ) return preds model = LogReg() data = { \"inputs\": np.random.random((1000, 764)), \"targets\": np.random.random((1000, 1)), \"sample_weight\": np.random.random((1000, 1)), } model.compile(keras.optimizers.Adam(1e-3)) model.fit(data, epochs=2) Epoch 1/2 32/32 [==============================] - 0s 833us/step - loss: 0.3499 - accuracy: 0.0000e+00 Epoch 2/2 32/32 [==============================] - 0s 643us/step - loss: 0.3443 - accuracy: 0.0000e+00 Modeling the relationship between training set size and model accuracy. Introduction In many real-world scenarios, the amount image data available to train a deep learning model is limited. This is especially true in the medical imaging domain, where dataset creation is costly. One of the first questions that usually comes up when approaching a new problem is: \"how many images will we need to train a good enough machine learning model?\" In most cases, a small set of samples is available, and we can use it to model the relationship between training data size and model performance. Such a model can be used to estimate the optimal number of images needed to arrive at a sample size that would achieve the required model performance. A systematic review of Sample-Size Determination Methodologies by Balki et al. provides examples of several sample-size determination methods. In this example, a balanced subsampling scheme is used to determine the optimal sample size for our model. This is done by selecting a random subsample consisting of Y number of images and training the model using the subsample. The model is then evaluated on an independent test set. This process is repeated N times for each subsample with replacement to allow for the construction of a mean and confidence interval for the observed performance. Setup import matplotlib.pyplot as plt import numpy as np import tensorflow as tf from tensorflow import keras import tensorflow_datasets as tfds from tensorflow.keras import layers # Define seed and fixed variables seed = 42 tf.random.set_seed(seed) np.random.seed(seed) AUTO = tf.data.AUTOTUNE Load TensorFlow dataset and convert to NumPy arrays We'll be using the TF Flowers dataset. # Specify dataset parameters dataset_name = \"tf_flowers\" batch_size = 64 image_size = (224, 224) # Load data from tfds and split 10% off for a test set (train_data, test_data), ds_info = tfds.load( dataset_name, split=[\"train[:90%]\", \"train[90%:]\"], shuffle_files=True, as_supervised=True, with_info=True, ) # Extract number of classes and list of class names num_classes = ds_info.features[\"label\"].num_classes class_names = ds_info.features[\"label\"].names print(f\"Number of classes: {num_classes}\") print(f\"Class names: {class_names}\") # Convert datasets to NumPy arrays def dataset_to_array(dataset, image_size, num_classes): images, labels = [], [] for img, lab in dataset.as_numpy_iterator(): images.append(tf.image.resize(img, image_size).numpy()) labels.append(tf.one_hot(lab, num_classes)) return np.array(images), np.array(labels) img_train, label_train = dataset_to_array(train_data, image_size, num_classes) img_test, label_test = dataset_to_array(test_data, image_size, num_classes) num_train_samples = len(img_train) print(f\"Number of training samples: {num_train_samples}\") Number of classes: 5 Class names: ['dandelion', 'daisy', 'tulips', 'sunflowers', 'roses'] Number of training samples: 3303 Plot a few examples from the test set plt.figure(figsize=(16, 12)) for n in range(30): ax = plt.subplot(5, 6, n + 1) plt.imshow(img_test[n].astype(\"uint8\")) plt.title(np.array(class_names)[label_test[n] == True][0]) plt.axis(\"off\") png Augmentation Define image augmentation using keras preprocessing layers and apply them to the training set. # Define image augmentation model image_augmentation = keras.Sequential( [ layers.RandomFlip(mode=\"horizontal\"), layers.RandomRotation(factor=0.1), layers.RandomZoom(height_factor=(-0.1, -0)), layers.RandomContrast(factor=0.1), ], ) # Apply the augmentations to the training images and plot a few examples img_train = image_augmentation(img_train).numpy() plt.figure(figsize=(16, 12)) for n in range(30): ax = plt.subplot(5, 6, n + 1) plt.imshow(img_train[n].astype(\"uint8\")) plt.title(np.array(class_names)[label_train[n] == True][0]) plt.axis(\"off\") png Define model building & training functions We create a few convenience functions to build a transfer-learning model, compile and train it and unfreeze layers for fine-tuning. def build_model(num_classes, img_size=image_size[0], top_dropout=0.3): \"\"\"Creates a classifier based on pre-trained MobileNetV2. Arguments: num_classes: Int, number of classese to use in the softmax layer. img_size: Int, square size of input images (defaults is 224). top_dropout: Int, value for dropout layer (defaults is 0.3). Returns: Uncompiled Keras model. \"\"\" # Create input and pre-processing layers for MobileNetV2 inputs = layers.Input(shape=(img_size, img_size, 3)) x = layers.Rescaling(scale=1.0 / 127.5, offset=-1)(inputs) model = keras.applications.MobileNetV2( include_top=False, weights=\"imagenet\", input_tensor=x ) # Freeze the pretrained weights model.trainable = False # Rebuild top x = layers.GlobalAveragePooling2D(name=\"avg_pool\")(model.output) x = layers.Dropout(top_dropout)(x) outputs = layers.Dense(num_classes, activation=\"softmax\")(x) model = keras.Model(inputs, outputs) print(\"Trainable weights:\", len(model.trainable_weights)) print(\"Non_trainable weights:\", len(model.non_trainable_weights)) return model def compile_and_train( model, training_data, training_labels, metrics=[keras.metrics.AUC(name=\"auc\"), \"acc\"], optimizer=keras.optimizers.Adam(), patience=5, epochs=5, ): \"\"\"Compiles and trains the model. Arguments: model: Uncompiled Keras model. training_data: NumPy Array, trainig data. training_labels: NumPy Array, trainig labels. metrics: Keras/TF metrics, requires at least 'auc' metric (default is `[keras.metrics.AUC(name='auc'), 'acc']`). optimizer: Keras/TF optimizer (defaults is `keras.optimizers.Adam()). patience: Int, epochsfor EarlyStopping patience (defaults is 5). epochs: Int, number of epochs to train (default is 5). Returns: Training history for trained Keras model. \"\"\" stopper = keras.callbacks.EarlyStopping( monitor=\"val_auc\", mode=\"max\", min_delta=0, patience=patience, verbose=1, restore_best_weights=True, ) model.compile(loss=\"categorical_crossentropy\", optimizer=optimizer, metrics=metrics) history = model.fit( x=training_data, y=training_labels, batch_size=batch_size, epochs=epochs, validation_split=0.1, callbacks=[stopper], ) return history def unfreeze(model, block_name, verbose=0): \"\"\"Unfreezes Keras model layers. Arguments: model: Keras model. block_name: Str, layer name for example block_name = 'block4'. Checks if supplied string is in the layer name. verbose: Int, 0 means silent, 1 prints out layers trainability status. Returns: Keras model with all layers after (and including) the specified block_name to trainable, excluding BatchNormalization layers. \"\"\" # Unfreeze from block_name onwards set_trainable = False for layer in model.layers: if block_name in layer.name: set_trainable = True if set_trainable and not isinstance(layer, layers.BatchNormalization): layer.trainable = True if verbose == 1: print(layer.name, \"trainable\") else: if verbose == 1: print(layer.name, \"NOT trainable\") print(\"Trainable weights:\", len(model.trainable_weights)) print(\"Non-trainable weights:\", len(model.non_trainable_weights)) return model Define iterative training function To train a model over several subsample sets we need to create an iterative training function. def train_model(training_data, training_labels): \"\"\"Trains the model as follows: - Trains only the top layers for 10 epochs. - Unfreezes deeper layers. - Train for 20 more epochs. Arguments: training_data: NumPy Array, trainig data. training_labels: NumPy Array, trainig labels. Returns: Model accuracy. \"\"\" model = build_model(num_classes) # Compile and train top layers history = compile_and_train( model, training_data, training_labels, metrics=[keras.metrics.AUC(name=\"auc\"), \"acc\"], optimizer=keras.optimizers.Adam(), patience=3, epochs=10, ) # Unfreeze model from block 10 onwards model = unfreeze(model, \"block_10\") # Compile and train for 20 epochs with a lower learning rate fine_tune_epochs = 20 total_epochs = history.epoch[-1] + fine_tune_epochs history_fine = compile_and_train( model, training_data, training_labels, metrics=[keras.metrics.AUC(name=\"auc\"), \"acc\"], optimizer=keras.optimizers.Adam(learning_rate=1e-4), patience=5, epochs=total_epochs, ) # Calculate model accuracy on the test set _, _, acc = model.evaluate(img_test, label_test) return np.round(acc, 4) Train models iteratively Now that we have model building functions and supporting iterative functions we can train the model over several subsample splits. We select the subsample splits as 5%, 10%, 25% and 50% of the downloaded dataset. We pretend that only 50% of the actual data is available at present. We train the model 5 times from scratch at each split and record the accuracy values. Note that this trains 20 models and will take some time. Make sure you have a GPU runtime active. To keep this example lightweight, sample data from a previous training run is provided. def train_iteratively(sample_splits=[0.05, 0.1, 0.25, 0.5], iter_per_split=5): \"\"\"Trains a model iteratively over several sample splits. Arguments: sample_splits: List/NumPy array, contains fractions of the trainins set to train over. iter_per_split: Int, number of times to train a model per sample split. Returns: Training accuracy for all splits and iterations and the number of samples used for training at each split. \"\"\" # Train all the sample models and calculate accuracy train_acc = [] sample_sizes = [] for fraction in sample_splits: print(f\"Fraction split: {fraction}\") # Repeat training 3 times for each sample size sample_accuracy = [] num_samples = int(num_train_samples * fraction) for i in range(iter_per_split): print(f\"Run {i+1} out of {iter_per_split}:\") # Create fractional subsets rand_idx = np.random.randint(num_train_samples, size=num_samples) train_img_subset = img_train[rand_idx, :] train_label_subset = label_train[rand_idx, :] # Train model and calculate accuracy accuracy = train_model(train_img_subset, train_label_subset) print(f\"Accuracy: {accuracy}\") sample_accuracy.append(accuracy) train_acc.append(sample_accuracy) sample_sizes.append(num_samples) return train_acc, sample_sizes # Running the above function produces the following outputs train_acc = [ [0.8202, 0.7466, 0.8011, 0.8447, 0.8229], [0.861, 0.8774, 0.8501, 0.8937, 0.891], [0.891, 0.9237, 0.8856, 0.9101, 0.891], [0.8937, 0.9373, 0.9128, 0.8719, 0.9128], ] sample_sizes = [165, 330, 825, 1651] Learning curve We now plot the learning curve by fitting an exponential curve through the mean accuracy points. We use TF to fit an exponential function through the data. We then extrapolate the learning curve to the predict the accuracy of a model trained on the whole training set. def fit_and_predict(train_acc, sample_sizes, pred_sample_size): \"\"\"Fits a learning curve to model training accuracy results. Arguments: train_acc: List/Numpy Array, training accuracy for all model training splits and iterations. sample_sizes: List/Numpy array, number of samples used for training at each split. pred_sample_size: Int, sample size to predict model accuracy based on fitted learning curve. \"\"\" x = sample_sizes mean_acc = [np.mean(i) for i in train_acc] error = [np.std(i) for i in train_acc] # Define mean squared error cost and exponential curve fit functions mse = keras.losses.MeanSquaredError() def exp_func(x, a, b): return a * x ** b # Define variables, learning rate and number of epochs for fitting with TF a = tf.Variable(0.0) b = tf.Variable(0.0) learning_rate = 0.01 training_epochs = 5000 # Fit the exponential function to the data for epoch in range(training_epochs): with tf.GradientTape() as tape: y_pred = exp_func(x, a, b) cost_function = mse(y_pred, mean_acc) # Get gradients and compute adjusted weights gradients = tape.gradient(cost_function, [a, b]) a.assign_sub(gradients[0] * learning_rate) b.assign_sub(gradients[1] * learning_rate) print(f\"Curve fit weights: a = {a.numpy()} and b = {b.numpy()}.\") # We can now estimate the accuracy for pred_sample_size max_acc = exp_func(pred_sample_size, a, b).numpy() # Print predicted x value and append to plot values print(f\"A model accuracy of {max_acc} is predicted for {pred_sample_size} samples.\") x_cont = np.linspace(x[0], pred_sample_size, 100) # Build the plot fig, ax = plt.subplots(figsize=(12, 6)) ax.errorbar(x, mean_acc, yerr=error, fmt=\"o\", label=\"Mean acc & std dev.\") ax.plot(x_cont, exp_func(x_cont, a, b), \"r-\", label=\"Fitted exponential curve.\") ax.set_ylabel(\"Model clasification accuracy.\", fontsize=12) ax.set_xlabel(\"Training sample size.\", fontsize=12) ax.set_xticks(np.append(x, pred_sample_size)) ax.set_yticks(np.append(mean_acc, max_acc)) ax.set_xticklabels(list(np.append(x, pred_sample_size)), rotation=90, fontsize=10) ax.yaxis.set_tick_params(labelsize=10) ax.set_title(\"Learning curve: model accuracy vs sample size.\", fontsize=14) ax.legend(loc=(0.75, 0.75), fontsize=10) ax.xaxis.grid(True) ax.yaxis.grid(True) plt.tight_layout() plt.show() # The mean absolute error (MAE) is calculated for curve fit to see how well # it fits the data. The lower the error the better the fit. mae = keras.losses.MeanAbsoluteError() print(f\"The mae for the curve fit is {mae(mean_acc, exp_func(x, a, b)).numpy()}.\") # We use the whole training set to predict the model accuracy fit_and_predict(train_acc, sample_sizes, pred_sample_size=num_train_samples) Curve fit weights: a = 0.6445642113685608 and b = 0.0480974055826664. A model accuracy of 0.9517360925674438 is predicted for 3303 samples. png The mae for the curve fit is 0.016098812222480774. From the extrapolated curve we can see that 3303 images will yield an estimated accuracy of about 95%. Now, let's use all the data (3303 images) and train the model to see if our prediction was accurate! # Now train the model with full dataset to get the actual accuracy accuracy = train_model(img_train, label_train) print(f\"A model accuracy of {accuracy} is reached on {num_train_samples} images!\") Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top.h5 9412608/9406464 [==============================] - 0s 0us/step Trainable weights: 2 Non_trainable weights: 260 Epoch 1/10 47/47 [==============================] - 34s 88ms/step - loss: 1.0756 - auc: 0.8513 - acc: 0.5821 - val_loss: 0.4947 - val_auc: 0.9761 - val_acc: 0.8429 Epoch 2/10 47/47 [==============================] - 3s 67ms/step - loss: 0.5470 - auc: 0.9629 - acc: 0.8022 - val_loss: 0.3746 - val_auc: 0.9854 - val_acc: 0.8882 Epoch 3/10 47/47 [==============================] - 3s 66ms/step - loss: 0.4495 - auc: 0.9744 - acc: 0.8445 - val_loss: 0.3474 - val_auc: 0.9861 - val_acc: 0.8882 Epoch 4/10 47/47 [==============================] - 3s 66ms/step - loss: 0.3914 - auc: 0.9802 - acc: 0.8647 - val_loss: 0.3171 - val_auc: 0.9882 - val_acc: 0.8912 Epoch 5/10 47/47 [==============================] - 3s 73ms/step - loss: 0.3631 - auc: 0.9832 - acc: 0.8681 - val_loss: 0.2983 - val_auc: 0.9895 - val_acc: 0.9003 Epoch 6/10 47/47 [==============================] - 3s 67ms/step - loss: 0.3242 - auc: 0.9867 - acc: 0.8856 - val_loss: 0.2915 - val_auc: 0.9898 - val_acc: 0.9003 Epoch 7/10 47/47 [==============================] - 3s 73ms/step - loss: 0.3016 - auc: 0.9883 - acc: 0.8930 - val_loss: 0.2912 - val_auc: 0.9895 - val_acc: 0.9033 Epoch 8/10 47/47 [==============================] - 3s 66ms/step - loss: 0.2765 - auc: 0.9906 - acc: 0.9017 - val_loss: 0.2824 - val_auc: 0.9900 - val_acc: 0.9033 Epoch 9/10 47/47 [==============================] - 3s 66ms/step - loss: 0.2721 - auc: 0.9907 - acc: 0.9028 - val_loss: 0.2804 - val_auc: 0.9899 - val_acc: 0.9033 Epoch 10/10 47/47 [==============================] - 3s 65ms/step - loss: 0.2564 - auc: 0.9914 - acc: 0.9098 - val_loss: 0.2913 - val_auc: 0.9891 - val_acc: 0.8973 Trainable weights: 24 Non-trainable weights: 238 Epoch 1/29 47/47 [==============================] - 9s 112ms/step - loss: 0.3316 - auc: 0.9850 - acc: 0.8789 - val_loss: 0.2392 - val_auc: 0.9915 - val_acc: 0.9033 Epoch 2/29 47/47 [==============================] - 4s 93ms/step - loss: 0.1497 - auc: 0.9966 - acc: 0.9478 - val_loss: 0.2797 - val_auc: 0.9906 - val_acc: 0.8731 Epoch 3/29 47/47 [==============================] - 4s 94ms/step - loss: 0.0981 - auc: 0.9982 - acc: 0.9640 - val_loss: 0.1795 - val_auc: 0.9960 - val_acc: 0.9366 Epoch 4/29 47/47 [==============================] - 4s 94ms/step - loss: 0.0652 - auc: 0.9990 - acc: 0.9788 - val_loss: 0.2161 - val_auc: 0.9924 - val_acc: 0.9275 Epoch 5/29 47/47 [==============================] - 4s 94ms/step - loss: 0.0327 - auc: 0.9999 - acc: 0.9896 - val_loss: 0.2161 - val_auc: 0.9919 - val_acc: 0.9517 Epoch 6/29 47/47 [==============================] - 4s 94ms/step - loss: 0.0269 - auc: 0.9999 - acc: 0.9923 - val_loss: 0.2485 - val_auc: 0.9894 - val_acc: 0.9335 Epoch 7/29 47/47 [==============================] - 4s 94ms/step - loss: 0.0174 - auc: 0.9998 - acc: 0.9956 - val_loss: 0.2692 - val_auc: 0.9871 - val_acc: 0.9215 Epoch 8/29 47/47 [==============================] - 4s 94ms/step - loss: 0.0253 - auc: 0.9999 - acc: 0.9913 - val_loss: 0.2645 - val_auc: 0.9864 - val_acc: 0.9275 Restoring model weights from the end of the best epoch. Epoch 00008: early stopping 12/12 [==============================] - 1s 39ms/step - loss: 0.1378 - auc: 0.9975 - acc: 0.9537 A model accuracy of 0.9537 is reached on 3303 images! Conclusion We see that a model accuracy of about 94-96%* is reached using 3303 images. This is quite close to our estimate! Even though we used only 50% of the dataset (1651 images) we were able to model the training behaviour of our model and predict the model accuracy for a given amount of images. This same methodology can be used to predict the amount of images needed to reach a desired accuracy. This is very useful when a smaller set of data is available, and it has been shown that convergence on a deep learning model is possible, but more images are needed. The image count prediction can be used to plan and budget for further image collection initiatives. This example shows how to use Keras callbacks to evaluate and export non-TensorFlow based metrics. Introduction Keras callbacks allow for the execution of arbitrary code at various stages of the Keras training process. While Keras offers first-class support for metric evaluation, Keras metrics may only rely on TensorFlow code internally. While there are TensorFlow implementations of many metrics online, some metrics are implemented using NumPy or another Python-based numerical computation library. By performing metric evaluation inside of a Keras callback, we can leverage any existing metric, and ultimately export the result to TensorBoard. Jaccard score metric This example makes use of a sklearn metric, sklearn.metrics.jaccard_score(), and writes the result to TensorBoard using the tf.summary API. This template can be modified slightly to make it work with any existing sklearn metric. import tensorflow as tf import tensorflow.keras as keras import tensorflow.keras.layers as layers from sklearn.metrics import jaccard_score import numpy as np import os class JaccardScoreCallback(keras.callbacks.Callback): \"\"\"Computes the Jaccard score and logs the results to TensorBoard.\"\"\" def __init__(self, model, x_test, y_test, log_dir): self.model = model self.x_test = x_test self.y_test = y_test self.keras_metric = tf.keras.metrics.Mean(\"jaccard_score\") self.epoch = 0 self.summary_writer = tf.summary.create_file_writer( os.path.join(log_dir, model.name) ) def on_epoch_end(self, batch, logs=None): self.epoch += 1 self.keras_metric.reset_state() predictions = self.model.predict(self.x_test) jaccard_value = jaccard_score( np.argmax(predictions, axis=-1), self.y_test, average=None ) self.keras_metric.update_state(jaccard_value) self._write_metric( self.keras_metric.name, self.keras_metric.result().numpy().astype(float) ) def _write_metric(self, name, value): with self.summary_writer.as_default(): tf.summary.scalar( name, value, step=self.epoch, ) self.summary_writer.flush() Sample usage Let's test our JaccardScoreCallback class with a Keras model. # Model / data parameters num_classes = 10 input_shape = (28, 28, 1) # The data, split between train and test sets (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() # Scale images to the [0, 1] range x_train = x_train.astype(\"float32\") / 255 x_test = x_test.astype(\"float32\") / 255 # Make sure images have shape (28, 28, 1) x_train = np.expand_dims(x_train, -1) x_test = np.expand_dims(x_test, -1) print(\"x_train shape:\", x_train.shape) print(x_train.shape[0], \"train samples\") print(x_test.shape[0], \"test samples\") # Convert class vectors to binary class matrices. y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) model = keras.Sequential( [ keras.Input(shape=input_shape), layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Conv2D(64, kernel_size=(3, 3), activation=\"relu\"), layers.MaxPooling2D(pool_size=(2, 2)), layers.Flatten(), layers.Dropout(0.5), layers.Dense(num_classes, activation=\"softmax\"), ] ) model.summary() batch_size = 128 epochs = 15 model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]) callbacks = [JaccardScoreCallback(model, x_test, np.argmax(y_test, axis=-1), \"logs\")] model.fit( x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1, callbacks=callbacks, ) x_train shape: (60000, 28, 28, 1) 60000 train samples 10000 test samples Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 26, 26, 32) 320 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 13, 13, 32) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 11, 11, 64) 18496 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 5, 5, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 1600) 0 _________________________________________________________________ dropout (Dropout) (None, 1600) 0 _________________________________________________________________ dense (Dense) (None, 10) 16010 ================================================================= Total params: 34,826 Trainable params: 34,826 Non-trainable params: 0 _________________________________________________________________ Epoch 1/15 422/422 [==============================] - 6s 14ms/step - loss: 0.3661 - accuracy: 0.8895 - val_loss: 0.0823 - val_accuracy: 0.9765 Epoch 2/15 422/422 [==============================] - 6s 14ms/step - loss: 0.1119 - accuracy: 0.9653 - val_loss: 0.0620 - val_accuracy: 0.9823 Epoch 3/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0841 - accuracy: 0.9742 - val_loss: 0.0488 - val_accuracy: 0.9873 Epoch 4/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0696 - accuracy: 0.9787 - val_loss: 0.0404 - val_accuracy: 0.9888 Epoch 5/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0615 - accuracy: 0.9813 - val_loss: 0.0406 - val_accuracy: 0.9897 Epoch 6/15 422/422 [==============================] - 6s 13ms/step - loss: 0.0565 - accuracy: 0.9826 - val_loss: 0.0373 - val_accuracy: 0.9900 Epoch 7/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0520 - accuracy: 0.9833 - val_loss: 0.0369 - val_accuracy: 0.9898 Epoch 8/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0488 - accuracy: 0.9851 - val_loss: 0.0353 - val_accuracy: 0.9905 Epoch 9/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0440 - accuracy: 0.9861 - val_loss: 0.0347 - val_accuracy: 0.9893 Epoch 10/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0424 - accuracy: 0.9871 - val_loss: 0.0294 - val_accuracy: 0.9907 Epoch 11/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0402 - accuracy: 0.9874 - val_loss: 0.0340 - val_accuracy: 0.9903 Epoch 12/15 422/422 [==============================] - 6s 13ms/step - loss: 0.0382 - accuracy: 0.9878 - val_loss: 0.0290 - val_accuracy: 0.9917 Epoch 13/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0358 - accuracy: 0.9886 - val_loss: 0.0286 - val_accuracy: 0.9923 Epoch 14/15 422/422 [==============================] - 6s 13ms/step - loss: 0.0349 - accuracy: 0.9885 - val_loss: 0.0282 - val_accuracy: 0.9918 Epoch 15/15 422/422 [==============================] - 6s 14ms/step - loss: 0.0323 - accuracy: 0.9899 - val_loss: 0.0283 - val_accuracy: 0.9922 If you now launch a TensorBoard instance using tensorboard --logdir=logs, you will see the jaccard_score metric alongside any other exported metrics! TensorBoard Jaccard Score Conclusion Many ML practitioners and researchers rely on metrics that may not yet have a TensorFlow implementation. Keras users can still leverage the wide variety of existing metric implementations in other frameworks by using a Keras callback. These metrics can be exported, viewed and analyzed in the TensorBoard like any other metric. Loading TFRecords for computer vision models. Introduction + Set Up TFRecords store a sequence of binary records, read linearly. They are useful format for storing data because they can be read efficiently. Learn more about TFRecords here. We'll explore how we can easily load in TFRecords for our melanoma classifier. import tensorflow as tf from functools import partial import matplotlib.pyplot as plt try: tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect() print(\"Device:\", tpu.master()) strategy = tf.distribute.TPUStrategy(tpu) except: strategy = tf.distribute.get_strategy() print(\"Number of replicas:\", strategy.num_replicas_in_sync) Number of replicas: 8 We want a bigger batch size as our data is not balanced. AUTOTUNE = tf.data.AUTOTUNE GCS_PATH = \"gs://kds-b38ce1b823c3ae623f5691483dbaa0f0363f04b0d6a90b63cf69946e\" BATCH_SIZE = 64 IMAGE_SIZE = [1024, 1024] Load the data FILENAMES = tf.io.gfile.glob(GCS_PATH + \"/tfrecords/train*.tfrec\") split_ind = int(0.9 * len(FILENAMES)) TRAINING_FILENAMES, VALID_FILENAMES = FILENAMES[:split_ind], FILENAMES[split_ind:] TEST_FILENAMES = tf.io.gfile.glob(GCS_PATH + \"/tfrecords/test*.tfrec\") print(\"Train TFRecord Files:\", len(TRAINING_FILENAMES)) print(\"Validation TFRecord Files:\", len(VALID_FILENAMES)) print(\"Test TFRecord Files:\", len(TEST_FILENAMES)) Train TFRecord Files: 14 Validation TFRecord Files: 2 Test TFRecord Files: 16 Decoding the data The images have to be converted to tensors so that it will be a valid input in our model. As images utilize an RBG scale, we specify 3 channels. We also reshape our data so that all of the images will be the same shape. def decode_image(image): image = tf.image.decode_jpeg(image, channels=3) image = tf.cast(image, tf.float32) image = tf.reshape(image, [*IMAGE_SIZE, 3]) return image As we load in our data, we need both our X and our Y. The X is our image; the model will find features and patterns in our image dataset. We want to predict Y, the probability that the lesion in the image is malignant. We will to through our TFRecords and parse out the image and the target values. def read_tfrecord(example, labeled): tfrecord_format = ( { \"image\": tf.io.FixedLenFeature([], tf.string), \"target\": tf.io.FixedLenFeature([], tf.int64), } if labeled else {\"image\": tf.io.FixedLenFeature([], tf.string),} ) example = tf.io.parse_single_example(example, tfrecord_format) image = decode_image(example[\"image\"]) if labeled: label = tf.cast(example[\"target\"], tf.int32) return image, label return image Define loading methods Our dataset is not ordered in any meaningful way, so the order can be ignored when loading our dataset. By ignoring the order and reading files as soon as they come in, it will take a shorter time to load the data. def load_dataset(filenames, labeled=True): ignore_order = tf.data.Options() ignore_order.experimental_deterministic = False # disable order, increase speed dataset = tf.data.TFRecordDataset( filenames ) # automatically interleaves reads from multiple files dataset = dataset.with_options( ignore_order ) # uses data as soon as it streams in, rather than in its original order dataset = dataset.map( partial(read_tfrecord, labeled=labeled), num_parallel_calls=AUTOTUNE ) # returns a dataset of (image, label) pairs if labeled=True or just images if labeled=False return dataset We define the following function to get our different datasets. def get_dataset(filenames, labeled=True): dataset = load_dataset(filenames, labeled=labeled) dataset = dataset.shuffle(2048) dataset = dataset.prefetch(buffer_size=AUTOTUNE) dataset = dataset.batch(BATCH_SIZE) return dataset Visualize input images train_dataset = get_dataset(TRAINING_FILENAMES) valid_dataset = get_dataset(VALID_FILENAMES) test_dataset = get_dataset(TEST_FILENAMES, labeled=False) image_batch, label_batch = next(iter(train_dataset)) def show_batch(image_batch, label_batch): plt.figure(figsize=(10, 10)) for n in range(25): ax = plt.subplot(5, 5, n + 1) plt.imshow(image_batch[n] / 255.0) if label_batch[n]: plt.title(\"MALIGNANT\") else: plt.title(\"BENIGN\") plt.axis(\"off\") show_batch(image_batch.numpy(), label_batch.numpy()) png Building our model Define callbacks The following function allows for the model to change the learning rate as it runs each epoch. We can use callbacks to stop training when there are no improvements in the model. At the end of the training process, the model will restore the weights of its best iteration. initial_learning_rate = 0.01 lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay( initial_learning_rate, decay_steps=20, decay_rate=0.96, staircase=True ) checkpoint_cb = tf.keras.callbacks.ModelCheckpoint( \"melanoma_model.h5\", save_best_only=True ) early_stopping_cb = tf.keras.callbacks.EarlyStopping( patience=10, restore_best_weights=True ) Build our base model Transfer learning is a great way to reap the benefits of a well-trained model without having the train the model ourselves. For this notebook, we want to import the Xception model. A more in-depth analysis of transfer learning can be found here. We do not want our metric to be accuracy because our data is imbalanced. For our example, we will be looking at the area under a ROC curve. def make_model(): base_model = tf.keras.applications.Xception( input_shape=(*IMAGE_SIZE, 3), include_top=False, weights=\"imagenet\" ) base_model.trainable = False inputs = tf.keras.layers.Input([*IMAGE_SIZE, 3]) x = tf.keras.applications.xception.preprocess_input(inputs) x = base_model(x) x = tf.keras.layers.GlobalAveragePooling2D()(x) x = tf.keras.layers.Dense(8, activation=\"relu\")(x) x = tf.keras.layers.Dropout(0.7)(x) outputs = tf.keras.layers.Dense(1, activation=\"sigmoid\")(x) model = tf.keras.Model(inputs=inputs, outputs=outputs) model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=lr_schedule), loss=\"binary_crossentropy\", metrics=tf.keras.metrics.AUC(name=\"auc\"), ) return model Train the model with strategy.scope(): model = make_model() history = model.fit( train_dataset, epochs=2, validation_data=valid_dataset, callbacks=[checkpoint_cb, early_stopping_cb], ) Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/xception/xception_weights_tf_dim_ordering_tf_kernels_notop.h5 83689472/83683744 [==============================] - 3s 0us/step Epoch 1/2 454/454 [==============================] - 525s 1s/step - loss: 0.1895 - auc: 0.5841 - val_loss: 0.0825 - val_auc: 0.8109 Epoch 2/2 454/454 [==============================] - 118s 260ms/step - loss: 0.1063 - auc: 0.5994 - val_loss: 0.0861 - val_auc: 0.8336 Predict results We'll use our model to predict results for our test dataset images. Values closer to 0 are more likely to be benign and values closer to 1 are more likely to be malignant. def show_batch_predictions(image_batch): plt.figure(figsize=(10, 10)) for n in range(25): ax = plt.subplot(5, 5, n + 1) plt.imshow(image_batch[n] / 255.0) img_array = tf.expand_dims(image_batch[n], axis=0) plt.title(model.predict(img_array)[0]) plt.axis(\"off\") image_batch = next(iter(test_dataset)) show_batch_predictions(image_batch) png Four simple tips to help you debug your Keras code. Introduction It's generally possible to do almost anything in Keras without writing code per se: whether you're implementing a new type of GAN or the latest convnet architecture for image segmentation, you can usually stick to calling built-in methods. Because all built-in methods do extensive input validation checks, you will have little to no debugging to do. A Functional API model made entirely of built-in layers will work on first try -- if you can compile it, it will run. However, sometimes, you will need to dive deeper and write your own code. Here are some common examples: Creating a new Layer subclass. Creating a custom Metric subclass. Implementing a custom train_step on a Model. This document provides a few simple tips to help you navigate debugging in these situations. Tip 1: test each part before you test the whole If you've created any object that has a chance of not working as expected, don't just drop it in your end-to-end process and watch sparks fly. Rather, test your custom object in isolation first. This may seem obvious -- but you'd be surprised how often people don't start with this. If you write a custom layer, don't call fit() on your entire model just yet. Call your layer on some test data first. If you write a custom metric, start by printing its output for some reference inputs. Here's a simple example. Let's write a custom layer a bug in it: import tensorflow as tf from tensorflow.keras import layers class MyAntirectifier(layers.Layer): def build(self, input_shape): output_dim = input_shape[-1] self.kernel = self.add_weight( shape=(output_dim * 2, output_dim), initializer=\"he_normal\", name=\"kernel\", trainable=True, ) def call(self, inputs): # Take the positive part of the input pos = tf.nn.relu(inputs) # Take the negative part of the input neg = tf.nn.relu(-inputs) # Concatenate the positive and negative parts concatenated = tf.concat([pos, neg], axis=0) # Project the concatenation down to the same dimensionality as the input return tf.matmul(concatenated, self.kernel) Now, rather than using it in a end-to-end model directly, let's try to call the layer on some test data: x = tf.random.normal(shape=(2, 5)) y = MyAntirectifier()(x) We get the following error: ... 1 x = tf.random.normal(shape=(2, 5)) ----> 2 y = MyAntirectifier()(x) ... 17 neg = tf.nn.relu(-inputs) 18 concatenated = tf.concat([pos, neg], axis=0) ---> 19 return tf.matmul(concatenated, self.kernel) ... InvalidArgumentError: Matrix size-incompatible: In[0]: [4,5], In[1]: [10,5] [Op:MatMul] Looks like our input tensor in the matmul op may have an incorrect shape. Let's add a print statement to check the actual shapes: class MyAntirectifier(layers.Layer): def build(self, input_shape): output_dim = input_shape[-1] self.kernel = self.add_weight( shape=(output_dim * 2, output_dim), initializer=\"he_normal\", name=\"kernel\", trainable=True, ) def call(self, inputs): pos = tf.nn.relu(inputs) neg = tf.nn.relu(-inputs) print(\"pos.shape:\", pos.shape) print(\"neg.shape:\", neg.shape) concatenated = tf.concat([pos, neg], axis=0) print(\"concatenated.shape:\", concatenated.shape) print(\"kernel.shape:\", self.kernel.shape) return tf.matmul(concatenated, self.kernel) We get the following: pos.shape: (2, 5) neg.shape: (2, 5) concatenated.shape: (4, 5) kernel.shape: (10, 5) Turns out we had the wrong axis for the concat op! We should be concatenating neg and pos alongside the feature axis 1, not the batch axis 0. Here's the correct version: class MyAntirectifier(layers.Layer): def build(self, input_shape): output_dim = input_shape[-1] self.kernel = self.add_weight( shape=(output_dim * 2, output_dim), initializer=\"he_normal\", name=\"kernel\", trainable=True, ) def call(self, inputs): pos = tf.nn.relu(inputs) neg = tf.nn.relu(-inputs) print(\"pos.shape:\", pos.shape) print(\"neg.shape:\", neg.shape) concatenated = tf.concat([pos, neg], axis=1) print(\"concatenated.shape:\", concatenated.shape) print(\"kernel.shape:\", self.kernel.shape) return tf.matmul(concatenated, self.kernel) Now our code works fine: x = tf.random.normal(shape=(2, 5)) y = MyAntirectifier()(x) pos.shape: (2, 5) neg.shape: (2, 5) concatenated.shape: (2, 10) kernel.shape: (10, 5) Tip 2: use model.summary() and plot_model() to check layer output shapes If you're working with complex network topologies, you're going to need a way to visualize how your layers are connected and how they transform the data that passes through them. Here's an example. Consider this model with three inputs and two outputs (lifted from the Functional API guide): from tensorflow import keras num_tags = 12 # Number of unique issue tags num_words = 10000 # Size of vocabulary obtained when preprocessing text data num_departments = 4 # Number of departments for predictions title_input = keras.Input( shape=(None,), name=\"title\" ) # Variable-length sequence of ints body_input = keras.Input(shape=(None,), name=\"body\") # Variable-length sequence of ints tags_input = keras.Input( shape=(num_tags,), name=\"tags\" ) # Binary vectors of size `num_tags` # Embed each word in the title into a 64-dimensional vector title_features = layers.Embedding(num_words, 64)(title_input) # Embed each word in the text into a 64-dimensional vector body_features = layers.Embedding(num_words, 64)(body_input) # Reduce sequence of embedded words in the title into a single 128-dimensional vector title_features = layers.LSTM(128)(title_features) # Reduce sequence of embedded words in the body into a single 32-dimensional vector body_features = layers.LSTM(32)(body_features) # Merge all available features into a single large vector via concatenation x = layers.concatenate([title_features, body_features, tags_input]) # Stick a logistic regression for priority prediction on top of the features priority_pred = layers.Dense(1, name=\"priority\")(x) # Stick a department classifier on top of the features department_pred = layers.Dense(num_departments, name=\"department\")(x) # Instantiate an end-to-end model predicting both priority and department model = keras.Model( inputs=[title_input, body_input, tags_input], outputs=[priority_pred, department_pred], ) Calling summary() can help you check the output shape of each layer: model.summary() Model: \"functional_1\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== title (InputLayer) [(None, None)] 0 __________________________________________________________________________________________________ body (InputLayer) [(None, None)] 0 __________________________________________________________________________________________________ embedding (Embedding) (None, None, 64) 640000 title[0][0] __________________________________________________________________________________________________ embedding_1 (Embedding) (None, None, 64) 640000 body[0][0] __________________________________________________________________________________________________ lstm (LSTM) (None, 128) 98816 embedding[0][0] __________________________________________________________________________________________________ lstm_1 (LSTM) (None, 32) 12416 embedding_1[0][0] __________________________________________________________________________________________________ tags (InputLayer) [(None, 12)] 0 __________________________________________________________________________________________________ concatenate (Concatenate) (None, 172) 0 lstm[0][0] lstm_1[0][0] tags[0][0] __________________________________________________________________________________________________ priority (Dense) (None, 1) 173 concatenate[0][0] __________________________________________________________________________________________________ department (Dense) (None, 4) 692 concatenate[0][0] ================================================================================================== Total params: 1,392,097 Trainable params: 1,392,097 Non-trainable params: 0 __________________________________________________________________________________________________ You can also visualize the entire network topology alongside output shapes using plot_model: keras.utils.plot_model(model, show_shapes=True) png With this plot, any connectivity-level error becomes immediately obvious. Tip 3: to debug what happens during fit(), use run_eagerly=True The fit() method is fast: it runs a well-optimized, fully-compiled computation graph. That's great for performance, but it also means that the code you're executing isn't the Python code you've written. This can be problematic when debugging. As you may recall, Python is slow -- so we use it as a staging language, not as an execution language. Thankfully, there's an easy way to run your code in \"debug mode\", fully eagerly: pass run_eagerly=True to compile(). Your call to fit() will now get executed line by line, without any optimization. It's slower, but it makes it possible to print the value of intermediate tensors, or to use a Python debugger. Great for debugging. Here's a basic example: let's write a really simple model with a custom train_step. Our model just implements gradient descent, but instead of first-order gradients, it uses a combination of first-order and second-order gradients. Pretty trivial so far. Can you spot what we're doing wrong? class MyModel(keras.Model): def train_step(self, data): inputs, targets = data trainable_vars = self.trainable_variables with tf.GradientTape() as tape2: with tf.GradientTape() as tape1: preds = self(inputs, training=True) # Forward pass # Compute the loss value # (the loss function is configured in `compile()`) loss = self.compiled_loss(targets, preds) # Compute first-order gradients dl_dw = tape1.gradient(loss, trainable_vars) # Compute second-order gradients d2l_dw2 = tape2.gradient(dl_dw, trainable_vars) # Combine first-order and second-order gradients grads = [0.5 * w1 + 0.5 * w2 for (w1, w2) in zip(d2l_dw2, dl_dw)] # Update weights self.optimizer.apply_gradients(zip(grads, trainable_vars)) # Update metrics (includes the metric that tracks the loss) self.compiled_metrics.update_state(targets, preds) # Return a dict mapping metric names to current value return {m.name: m.result() for m in self.metrics} Let's train a one-layer model on MNIST with this custom training loop. We pick, somewhat at random, a batch size of 1024 and a learning rate of 0.1. The general idea being to use larger batches and a larger learning rate than usual, since our \"improved\" gradients should lead us to quicker convergence. import numpy as np # Construct an instance of MyModel def get_model(): inputs = keras.Input(shape=(784,)) intermediate = layers.Dense(256, activation=\"relu\")(inputs) outputs = layers.Dense(10, activation=\"softmax\")(intermediate) model = MyModel(inputs, outputs) return model # Prepare data (x_train, y_train), _ = keras.datasets.mnist.load_data() x_train = np.reshape(x_train, (-1, 784)) / 255 model = get_model() model.compile( optimizer=keras.optimizers.SGD(learning_rate=1e-2), loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"], ) model.fit(x_train, y_train, epochs=3, batch_size=1024, validation_split=0.1) Epoch 1/3 53/53 [==============================] - 1s 15ms/step - loss: 2.2960 - accuracy: 0.1580 - val_loss: 2.3071 - val_accuracy: 0.0963 Epoch 2/3 53/53 [==============================] - 1s 13ms/step - loss: 2.3246 - accuracy: 0.0995 - val_loss: 2.3454 - val_accuracy: 0.0960 Epoch 3/3 53/53 [==============================] - 1s 12ms/step - loss: 2.3578 - accuracy: 0.0995 - val_loss: 2.3767 - val_accuracy: 0.0960 Oh no, it doesn't converge! Something is not working as planned. Time for some step-by-step printing of what's going on with our gradients. We add various print statements in the train_step method, and we make sure to pass run_eagerly=True to compile() to run our code step-by-step, eagerly. class MyModel(keras.Model): def train_step(self, data): print() print(\"----Start of step: %d\" % (self.step_counter,)) self.step_counter += 1 inputs, targets = data trainable_vars = self.trainable_variables with tf.GradientTape() as tape2: with tf.GradientTape() as tape1: preds = self(inputs, training=True) # Forward pass # Compute the loss value # (the loss function is configured in `compile()`) loss = self.compiled_loss(targets, preds) # Compute first-order gradients dl_dw = tape1.gradient(loss, trainable_vars) # Compute second-order gradients d2l_dw2 = tape2.gradient(dl_dw, trainable_vars) print(\"Max of dl_dw[0]: %.4f\" % tf.reduce_max(dl_dw[0])) print(\"Min of dl_dw[0]: %.4f\" % tf.reduce_min(dl_dw[0])) print(\"Mean of dl_dw[0]: %.4f\" % tf.reduce_mean(dl_dw[0])) print(\"-\") print(\"Max of d2l_dw2[0]: %.4f\" % tf.reduce_max(d2l_dw2[0])) print(\"Min of d2l_dw2[0]: %.4f\" % tf.reduce_min(d2l_dw2[0])) print(\"Mean of d2l_dw2[0]: %.4f\" % tf.reduce_mean(d2l_dw2[0])) # Combine first-order and second-order gradients grads = [0.5 * w1 + 0.5 * w2 for (w1, w2) in zip(d2l_dw2, dl_dw)] # Update weights self.optimizer.apply_gradients(zip(grads, trainable_vars)) # Update metrics (includes the metric that tracks the loss) self.compiled_metrics.update_state(targets, preds) # Return a dict mapping metric names to current value return {m.name: m.result() for m in self.metrics} model = get_model() model.compile( optimizer=keras.optimizers.SGD(learning_rate=1e-2), loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"], run_eagerly=True, ) model.step_counter = 0 # We pass epochs=1 and steps_per_epoch=10 to only run 10 steps of training. model.fit(x_train, y_train, epochs=1, batch_size=1024, verbose=0, steps_per_epoch=10) ----Start of step: 0 Max of dl_dw[0]: 0.0236 Min of dl_dw[0]: -0.0198 Mean of dl_dw[0]: 0.0001 - Max of d2l_dw2[0]: 2.6148 Min of d2l_dw2[0]: -1.8798 Mean of d2l_dw2[0]: 0.0401 ----Start of step: 1 Max of dl_dw[0]: 0.0611 Min of dl_dw[0]: -0.0233 Mean of dl_dw[0]: 0.0009 - Max of d2l_dw2[0]: 8.3185 Min of d2l_dw2[0]: -4.0696 Mean of d2l_dw2[0]: 0.1708 ----Start of step: 2 Max of dl_dw[0]: 0.0528 Min of dl_dw[0]: -0.0200 Mean of dl_dw[0]: 0.0010 - Max of d2l_dw2[0]: 3.4744 Min of d2l_dw2[0]: -3.1926 Mean of d2l_dw2[0]: 0.0559 ----Start of step: 3 Max of dl_dw[0]: 0.0983 Min of dl_dw[0]: -0.0174 Mean of dl_dw[0]: 0.0014 - Max of d2l_dw2[0]: 2.2682 Min of d2l_dw2[0]: -0.7935 Mean of d2l_dw2[0]: 0.0253 ----Start of step: 4 Max of dl_dw[0]: 0.0732 Min of dl_dw[0]: -0.0125 Mean of dl_dw[0]: 0.0009 - Max of d2l_dw2[0]: 5.1099 Min of d2l_dw2[0]: -2.4236 Mean of d2l_dw2[0]: 0.0860 ----Start of step: 5 Max of dl_dw[0]: 0.1309 Min of dl_dw[0]: -0.0103 Mean of dl_dw[0]: 0.0007 - Max of d2l_dw2[0]: 5.1275 Min of d2l_dw2[0]: -0.6684 Mean of d2l_dw2[0]: 0.0349 ----Start of step: 6 Max of dl_dw[0]: 0.0484 Min of dl_dw[0]: -0.0128 Mean of dl_dw[0]: 0.0001 - Max of d2l_dw2[0]: 5.3465 Min of d2l_dw2[0]: -0.2145 Mean of d2l_dw2[0]: 0.0618 ----Start of step: 7 Max of dl_dw[0]: 0.0049 Min of dl_dw[0]: -0.0093 Mean of dl_dw[0]: -0.0001 - Max of d2l_dw2[0]: 0.2465 Min of d2l_dw2[0]: -0.0313 Mean of d2l_dw2[0]: 0.0075 ----Start of step: 8 Max of dl_dw[0]: 0.0050 Min of dl_dw[0]: -0.0120 Mean of dl_dw[0]: -0.0001 - Max of d2l_dw2[0]: 0.1978 Min of d2l_dw2[0]: -0.0291 Mean of d2l_dw2[0]: 0.0063 ----Start of step: 9 Max of dl_dw[0]: 0.0050 Min of dl_dw[0]: -0.0125 Mean of dl_dw[0]: -0.0001 - Max of d2l_dw2[0]: 0.1594 Min of d2l_dw2[0]: -0.0238 Mean of d2l_dw2[0]: 0.0055 What did we learn? The first order and second order gradients can have values that differ by orders of magnitudes. Sometimes, they may not even have the same sign. Their values can vary greatly at each step. This leads us to an obvious idea: let's normalize the gradients before combining them. class MyModel(keras.Model): def train_step(self, data): inputs, targets = data trainable_vars = self.trainable_variables with tf.GradientTape() as tape2: with tf.GradientTape() as tape1: preds = self(inputs, training=True) # Forward pass # Compute the loss value # (the loss function is configured in `compile()`) loss = self.compiled_loss(targets, preds) # Compute first-order gradients dl_dw = tape1.gradient(loss, trainable_vars) # Compute second-order gradients d2l_dw2 = tape2.gradient(dl_dw, trainable_vars) dl_dw = [tf.math.l2_normalize(w) for w in dl_dw] d2l_dw2 = [tf.math.l2_normalize(w) for w in d2l_dw2] # Combine first-order and second-order gradients grads = [0.5 * w1 + 0.5 * w2 for (w1, w2) in zip(d2l_dw2, dl_dw)] # Update weights self.optimizer.apply_gradients(zip(grads, trainable_vars)) # Update metrics (includes the metric that tracks the loss) self.compiled_metrics.update_state(targets, preds) # Return a dict mapping metric names to current value return {m.name: m.result() for m in self.metrics} model = get_model() model.compile( optimizer=keras.optimizers.SGD(learning_rate=1e-2), loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"], ) model.fit(x_train, y_train, epochs=5, batch_size=1024, validation_split=0.1) Epoch 1/5 53/53 [==============================] - 1s 15ms/step - loss: 2.1680 - accuracy: 0.2796 - val_loss: 2.0063 - val_accuracy: 0.4688 Epoch 2/5 53/53 [==============================] - 1s 13ms/step - loss: 1.9071 - accuracy: 0.5292 - val_loss: 1.7729 - val_accuracy: 0.6312 Epoch 3/5 53/53 [==============================] - 1s 13ms/step - loss: 1.7098 - accuracy: 0.6197 - val_loss: 1.5966 - val_accuracy: 0.6785 Epoch 4/5 53/53 [==============================] - 1s 13ms/step - loss: 1.5686 - accuracy: 0.6434 - val_loss: 1.4748 - val_accuracy: 0.6875 Epoch 5/5 53/53 [==============================] - 1s 14ms/step - loss: 1.4729 - accuracy: 0.6448 - val_loss: 1.3908 - val_accuracy: 0.6862 Now, training converges! It doesn't work well at all, but at least the model learns something. After spending a few minutes tuning parameters, we get to the following configuration that works somewhat well (achieves 97% validation accuracy and seems reasonably robust to overfitting): Use 0.2 * w1 + 0.8 * w2 for combining gradients. Use a learning rate that decays linearly over time. I'm not going to say that the idea works -- this isn't at all how you're supposed to do second-order optimization (pointers: see the Newton & Gauss-Newton methods, quasi-Newton methods, and BFGS). But hopefully this demonstration gave you an idea of how you can debug your way out of uncomfortable training situations. Remember: use run_eagerly=True for debugging what happens in fit(). And when your code is finally working as expected, make sure to remove this flag in order to get the best runtime performance! Here's our final training run: class MyModel(keras.Model): def train_step(self, data): inputs, targets = data trainable_vars = self.trainable_variables with tf.GradientTape() as tape2: with tf.GradientTape() as tape1: preds = self(inputs, training=True) # Forward pass # Compute the loss value # (the loss function is configured in `compile()`) loss = self.compiled_loss(targets, preds) # Compute first-order gradients dl_dw = tape1.gradient(loss, trainable_vars) # Compute second-order gradients d2l_dw2 = tape2.gradient(dl_dw, trainable_vars) dl_dw = [tf.math.l2_normalize(w) for w in dl_dw] d2l_dw2 = [tf.math.l2_normalize(w) for w in d2l_dw2] # Combine first-order and second-order gradients grads = [0.2 * w1 + 0.8 * w2 for (w1, w2) in zip(d2l_dw2, dl_dw)] # Update weights self.optimizer.apply_gradients(zip(grads, trainable_vars)) # Update metrics (includes the metric that tracks the loss) self.compiled_metrics.update_state(targets, preds) # Return a dict mapping metric names to current value return {m.name: m.result() for m in self.metrics} model = get_model() lr = learning_rate = keras.optimizers.schedules.InverseTimeDecay( initial_learning_rate=0.1, decay_steps=25, decay_rate=0.1 ) model.compile( optimizer=keras.optimizers.SGD(lr), loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"], ) model.fit(x_train, y_train, epochs=50, batch_size=2048, validation_split=0.1) Epoch 1/50 27/27 [==============================] - 1s 31ms/step - loss: 1.3838 - accuracy: 0.6598 - val_loss: 0.6603 - val_accuracy: 0.8688 Epoch 2/50 27/27 [==============================] - 1s 29ms/step - loss: 0.5872 - accuracy: 0.8547 - val_loss: 0.4188 - val_accuracy: 0.8977 Epoch 3/50 27/27 [==============================] - 1s 31ms/step - loss: 0.4481 - accuracy: 0.8782 - val_loss: 0.3434 - val_accuracy: 0.9113 Epoch 4/50 27/27 [==============================] - 1s 32ms/step - loss: 0.3857 - accuracy: 0.8933 - val_loss: 0.3149 - val_accuracy: 0.9115 Epoch 5/50 27/27 [==============================] - 1s 30ms/step - loss: 0.3482 - accuracy: 0.9020 - val_loss: 0.2752 - val_accuracy: 0.9248 Epoch 6/50 27/27 [==============================] - 1s 34ms/step - loss: 0.3219 - accuracy: 0.9091 - val_loss: 0.2549 - val_accuracy: 0.9287 Epoch 7/50 27/27 [==============================] - 1s 30ms/step - loss: 0.3023 - accuracy: 0.9147 - val_loss: 0.2480 - val_accuracy: 0.9305 Epoch 8/50 27/27 [==============================] - 1s 33ms/step - loss: 0.2866 - accuracy: 0.9188 - val_loss: 0.2327 - val_accuracy: 0.9362 Epoch 9/50 27/27 [==============================] - 1s 39ms/step - loss: 0.2733 - accuracy: 0.9228 - val_loss: 0.2226 - val_accuracy: 0.9383 Epoch 10/50 27/27 [==============================] - 1s 33ms/step - loss: 0.2613 - accuracy: 0.9267 - val_loss: 0.2147 - val_accuracy: 0.9420 Epoch 11/50 27/27 [==============================] - 1s 34ms/step - loss: 0.2509 - accuracy: 0.9294 - val_loss: 0.2049 - val_accuracy: 0.9447 Epoch 12/50 27/27 [==============================] - 1s 32ms/step - loss: 0.2417 - accuracy: 0.9324 - val_loss: 0.1978 - val_accuracy: 0.9455 Epoch 13/50 27/27 [==============================] - 1s 32ms/step - loss: 0.2330 - accuracy: 0.9345 - val_loss: 0.1906 - val_accuracy: 0.9488 Epoch 14/50 27/27 [==============================] - 1s 34ms/step - loss: 0.2252 - accuracy: 0.9372 - val_loss: 0.1853 - val_accuracy: 0.9508 Epoch 15/50 27/27 [==============================] - 1s 34ms/step - loss: 0.2184 - accuracy: 0.9392 - val_loss: 0.1805 - val_accuracy: 0.9523 Epoch 16/50 27/27 [==============================] - 1s 38ms/step - loss: 0.2113 - accuracy: 0.9413 - val_loss: 0.1760 - val_accuracy: 0.9518 Epoch 17/50 27/27 [==============================] - 1s 38ms/step - loss: 0.2055 - accuracy: 0.9427 - val_loss: 0.1709 - val_accuracy: 0.9552 Epoch 18/50 27/27 [==============================] - 1s 42ms/step - loss: 0.1998 - accuracy: 0.9441 - val_loss: 0.1669 - val_accuracy: 0.9567 Epoch 19/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1944 - accuracy: 0.9458 - val_loss: 0.1625 - val_accuracy: 0.9577 Epoch 20/50 27/27 [==============================] - 1s 33ms/step - loss: 0.1891 - accuracy: 0.9471 - val_loss: 0.1580 - val_accuracy: 0.9585 Epoch 21/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1846 - accuracy: 0.9484 - val_loss: 0.1564 - val_accuracy: 0.9603 Epoch 22/50 27/27 [==============================] - 1s 41ms/step - loss: 0.1804 - accuracy: 0.9498 - val_loss: 0.1518 - val_accuracy: 0.9622 Epoch 23/50 27/27 [==============================] - 1s 38ms/step - loss: 0.1762 - accuracy: 0.9507 - val_loss: 0.1485 - val_accuracy: 0.9628 Epoch 24/50 27/27 [==============================] - 1s 41ms/step - loss: 0.1722 - accuracy: 0.9521 - val_loss: 0.1461 - val_accuracy: 0.9623 Epoch 25/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1686 - accuracy: 0.9534 - val_loss: 0.1434 - val_accuracy: 0.9633 Epoch 26/50 27/27 [==============================] - 1s 35ms/step - loss: 0.1652 - accuracy: 0.9542 - val_loss: 0.1419 - val_accuracy: 0.9637 Epoch 27/50 27/27 [==============================] - 1s 34ms/step - loss: 0.1618 - accuracy: 0.9550 - val_loss: 0.1397 - val_accuracy: 0.9633 Epoch 28/50 27/27 [==============================] - 1s 35ms/step - loss: 0.1589 - accuracy: 0.9556 - val_loss: 0.1371 - val_accuracy: 0.9647 Epoch 29/50 27/27 [==============================] - 1s 37ms/step - loss: 0.1561 - accuracy: 0.9566 - val_loss: 0.1350 - val_accuracy: 0.9650 Epoch 30/50 27/27 [==============================] - 1s 41ms/step - loss: 0.1534 - accuracy: 0.9574 - val_loss: 0.1331 - val_accuracy: 0.9655 Epoch 31/50 27/27 [==============================] - 1s 39ms/step - loss: 0.1508 - accuracy: 0.9583 - val_loss: 0.1319 - val_accuracy: 0.9660 Epoch 32/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1484 - accuracy: 0.9589 - val_loss: 0.1314 - val_accuracy: 0.9667 Epoch 33/50 27/27 [==============================] - 1s 39ms/step - loss: 0.1463 - accuracy: 0.9597 - val_loss: 0.1290 - val_accuracy: 0.9668 Epoch 34/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1439 - accuracy: 0.9600 - val_loss: 0.1268 - val_accuracy: 0.9675 Epoch 35/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1418 - accuracy: 0.9608 - val_loss: 0.1256 - val_accuracy: 0.9677 Epoch 36/50 27/27 [==============================] - 1s 38ms/step - loss: 0.1397 - accuracy: 0.9614 - val_loss: 0.1245 - val_accuracy: 0.9685 Epoch 37/50 27/27 [==============================] - 1s 35ms/step - loss: 0.1378 - accuracy: 0.9625 - val_loss: 0.1223 - val_accuracy: 0.9683 Epoch 38/50 27/27 [==============================] - 1s 38ms/step - loss: 0.1362 - accuracy: 0.9620 - val_loss: 0.1216 - val_accuracy: 0.9695 Epoch 39/50 27/27 [==============================] - 1s 38ms/step - loss: 0.1344 - accuracy: 0.9628 - val_loss: 0.1207 - val_accuracy: 0.9685 Epoch 40/50 27/27 [==============================] - 1s 37ms/step - loss: 0.1327 - accuracy: 0.9634 - val_loss: 0.1192 - val_accuracy: 0.9692 Epoch 41/50 27/27 [==============================] - 1s 41ms/step - loss: 0.1309 - accuracy: 0.9635 - val_loss: 0.1179 - val_accuracy: 0.9695 Epoch 42/50 27/27 [==============================] - 1s 39ms/step - loss: 0.1294 - accuracy: 0.9641 - val_loss: 0.1173 - val_accuracy: 0.9695 Epoch 43/50 27/27 [==============================] - 1s 41ms/step - loss: 0.1281 - accuracy: 0.9646 - val_loss: 0.1160 - val_accuracy: 0.9705 Epoch 44/50 27/27 [==============================] - 1s 42ms/step - loss: 0.1265 - accuracy: 0.9650 - val_loss: 0.1158 - val_accuracy: 0.9700 Epoch 45/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1251 - accuracy: 0.9654 - val_loss: 0.1149 - val_accuracy: 0.9695 Epoch 46/50 27/27 [==============================] - 1s 39ms/step - loss: 0.1237 - accuracy: 0.9658 - val_loss: 0.1140 - val_accuracy: 0.9700 Epoch 47/50 27/27 [==============================] - 1s 40ms/step - loss: 0.1224 - accuracy: 0.9664 - val_loss: 0.1128 - val_accuracy: 0.9707 Epoch 48/50 27/27 [==============================] - 1s 38ms/step - loss: 0.1211 - accuracy: 0.9664 - val_loss: 0.1122 - val_accuracy: 0.9710 Epoch 49/50 27/27 [==============================] - 1s 39ms/step - loss: 0.1198 - accuracy: 0.9670 - val_loss: 0.1114 - val_accuracy: 0.9713 Epoch 50/50 27/27 [==============================] - 1s 45ms/step - loss: 0.1186 - accuracy: 0.9677 - val_loss: 0.1106 - val_accuracy: 0.9703 Tip 4: if your code is slow, run the TensorFlow profiler One last tip -- if your code seems slower than it should be, you're going to want to plot how much time is spent on each computation step. Look for any bottleneck that might be causing less than 100% device utilization. To learn more about TensorFlow profiling, see this extensive guide. You can quickly profile a Keras model via the TensorBoard callback: # Profile from batches 10 to 15 tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, profile_batch=(10, 15)) # Train the model and use the TensorBoard Keras callback to collect # performance profiling data model.fit(dataset, epochs=1, callbacks=[tb_callback]) Then navigate to the TensorBoard app and check the \"profile\" tab. Training better student models via knowledge distillation with function matching. Introduction Knowledge distillation (Hinton et al.) is a technique that enables us to compress larger models into smaller ones. This allows us to reap the benefits of high performing larger models, while reducing storage and memory costs and achieving higher inference speed: Smaller models -> smaller memory footprint Reduced complexity -> fewer floating-point operations (FLOPs) In Knowledge distillation: A good teacher is patient and consistent, Beyer et al. investigate various existing setups for performing knowledge distillation and show that all of them lead to sub-optimal performance. Due to this, practitioners often settle for other alternatives (quantization, pruning, weight clustering, etc.) when developing production systems that are resource-constrained. Beyer et al. investigate how we can improve the student models that come out of the knowledge distillation process and always match the performance of their teacher models. In this example, we will study the recipes introduced by them, using the Flowers102 dataset. As a reference, with these recipes, the authors were able to produce a ResNet50 model that achieves 82.8% accuracy on the ImageNet-1k dataset. In case you need a refresher on knowledge distillation and want to study how it is implemented in Keras, you can refer to this example. You can also follow this example that shows an extension of knowledge distillation applied to consistency training. To follow this example, you will need TensorFlow 2.5 or higher as well as TensorFlow Addons, which can be installed using the command below: !pip install -q tensorflow-addons Imports from tensorflow import keras import tensorflow_addons as tfa import tensorflow as tf import matplotlib.pyplot as plt import numpy as np import tensorflow_datasets as tfds tfds.disable_progress_bar() Hyperparameters and contants AUTO = tf.data.AUTOTUNE # Used to dynamically adjust parallelism. BATCH_SIZE = 64 # Comes from Table 4 and \"Training setup\" section. TEMPERATURE = 10 # Used to soften the logits before they go to softmax. INIT_LR = 0.003 # Initial learning rate that will be decayed over the training period. WEIGHT_DECAY = 0.001 # Used for regularization. CLIP_THRESHOLD = 1.0 # Used for clipping the gradients by L2-norm. # We will first resize the training images to a bigger size and then we will take # random crops of a lower size. BIGGER = 160 RESIZE = 128 Load the Flowers102 dataset train_ds, validation_ds, test_ds = tfds.load( \"oxford_flowers102\", split=[\"train\", \"validation\", \"test\"], as_supervised=True ) print(f\"Number of training examples: {train_ds.cardinality()}.\") print( f\"Number of validation examples: {validation_ds.cardinality()}.\" ) print(f\"Number of test examples: {test_ds.cardinality()}.\") Number of training examples: 1020. Number of validation examples: 1020. Number of test examples: 6149. Teacher model As is common with any distillation technique, it's important to first train a well-performing teacher model which is usually larger than the subsequent student model. The authors distill a BiT ResNet152x2 model (teacher) into a BiT ResNet50 model (student). BiT stands for Big Transfer and was introduced in Big Transfer (BiT): General Visual Representation Learning. BiT variants of ResNets use Group Normalization (Wu et al.) and Weight Standardization (Qiao et al.) in place of Batch Normalization (Ioffe et al.). In order to limit the time it takes to run this example, we will be using a BiT ResNet101x3 already trained on the Flowers102 dataset. You can refer to this notebook to learn more about the training process. This model reaches 98.18% accuracy on the test set of Flowers102. The model weights are hosted on Kaggle as a dataset. To download the weights, follow these steps: Create an account on Kaggle here. Go to the \"Account\" tab of your user profile. Select \"Create API Token\". This will trigger the download of kaggle.json, a file containing your API credentials. From that JSON file, copy your Kaggle username and API key. Now run the following: import os os.environ[\"KAGGLE_USERNAME\"] = \"\" # TODO: enter your Kaggle user name here os.environ[\"KAGGLE_KEY\"] = \"\" # TODO: enter your Kaggle key here Once the environment variables are set, run: $ kaggle datasets download -d spsayakpaul/bitresnet101x3flowers102 $ unzip -qq bitresnet101x3flowers102.zip This should generate a folder named T-r101x3-128 which is essentially a teacher SavedModel. import os os.environ[\"KAGGLE_USERNAME\"] = \"\" # TODO: enter your Kaggle user name here os.environ[\"KAGGLE_KEY\"] = \"\" # TODO: enter your Kaggle API key here !kaggle datasets download -d spsayakpaul/bitresnet101x3flowers102 !unzip -qq bitresnet101x3flowers102.zip # Since the teacher model is not going to be trained further we make # it non-trainable. teacher_model = keras.models.load_model( \"/home/jupyter/keras-io/examples/keras_recipes/T-r101x3-128\" ) teacher_model.trainable = False teacher_model.summary() Model: \"my_bi_t_model_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_1 (Dense) multiple 626790 _________________________________________________________________ keras_layer_1 (KerasLayer) multiple 381789888 ================================================================= Total params: 382,416,678 Trainable params: 0 Non-trainable params: 382,416,678 _________________________________________________________________ The \"function matching\" recipe To train a high-quality student model, the authors propose the following changes to the student training workflow: Use an aggressive variant of MixUp (Zhang et al.). This is done by sampling the alpha parameter from a uniform distribution instead of a beta distribution. MixUp is used here in order to help the student model capture the function underlying the teacher model. MixUp linearly interpolates between different samples across the data manifold. So the rationale here is if the student is trained to fit that it should be able to match the teacher model better. To incorporate more invariance MixUp is coupled with \"Inception-style\" cropping (Szegedy et al.). This is where the \"function matching\" term makes its way in the original paper. Unlike other works (Noisy Student Training for example), both the teacher and student models receive the same copy of an image, which is mixed up and randomly cropped. By providing the same inputs to both the models, the authors make the teacher consistent with the student. With MixUp, we are essentially introducing a strong form of regularization when training the student. As such, it should be trained for a relatively long period of time (1000 epochs at least). Since the student is trained with strong regularization, the risk of overfitting due to a longer training schedule are also mitigated. In summary, one needs to be consistent and patient while training the student model. Data input pipeline def mixup(images, labels): alpha = tf.random.uniform([], 0, 1) mixedup_images = alpha * images + (1 - alpha) * tf.reverse(images, axis=[0]) # The labels do not matter here since they are NOT used during # training. return mixedup_images, labels def preprocess_image(image, label, train=True): image = tf.cast(image, tf.float32) / 255.0 if train: image = tf.image.resize(image, (BIGGER, BIGGER)) image = tf.image.random_crop(image, (RESIZE, RESIZE, 3)) image = tf.image.random_flip_left_right(image) else: # Central fraction amount is from here: # https://git.io/J8Kda. image = tf.image.central_crop(image, central_fraction=0.875) image = tf.image.resize(image, (RESIZE, RESIZE)) return image, label def prepare_dataset(dataset, train=True, batch_size=BATCH_SIZE): if train: dataset = dataset.map(preprocess_image, num_parallel_calls=AUTO) dataset = dataset.shuffle(BATCH_SIZE * 10) else: dataset = dataset.map( lambda x, y: (preprocess_image(x, y, train)), num_parallel_calls=AUTO ) dataset = dataset.batch(batch_size) if train: dataset = dataset.map(mixup, num_parallel_calls=AUTO) dataset = dataset.prefetch(AUTO) return dataset Note that for brevity, we used mild crops for the training set but in practice \"Inception-style\" preprocessing should be applied. You can refer to this script for a closer implementation. Also, the ground-truth labels are not used for training the student. train_ds = prepare_dataset(train_ds, True) validation_ds = prepare_dataset(validation_ds, False) test_ds = prepare_dataset(test_ds, False) Visualization sample_images, _ = next(iter(train_ds)) plt.figure(figsize=(10, 10)) for n in range(25): ax = plt.subplot(5, 5, n + 1) plt.imshow(sample_images[n].numpy()) plt.axis(\"off\") plt.show() png Student model For the purpose of this example, we will use the standard ResNet50V2 (He et al.). def get_resnetv2(): resnet_v2 = keras.applications.ResNet50V2( weights=None, input_shape=(RESIZE, RESIZE, 3), classes=102, classifier_activation=\"linear\", ) return resnet_v2 get_resnetv2().count_params() 23773798 Compared to the teacher model, this model has 358 Million fewer parameters. Distillation utility We will reuse some code from this example on knowledge distillation. class Distiller(tf.keras.Model): def __init__(self, student, teacher): super(Distiller, self).__init__() self.student = student self.teacher = teacher self.loss_tracker = keras.metrics.Mean(name=\"distillation_loss\") @property def metrics(self): metrics = super().metrics metrics.append(self.loss_tracker) return metrics def compile( self, optimizer, metrics, distillation_loss_fn, temperature=TEMPERATURE, ): super(Distiller, self).compile(optimizer=optimizer, metrics=metrics) self.distillation_loss_fn = distillation_loss_fn self.temperature = temperature def train_step(self, data): # Unpack data x, _ = data # Forward pass of teacher teacher_predictions = self.teacher(x, training=False) with tf.GradientTape() as tape: # Forward pass of student student_predictions = self.student(x, training=True) # Compute loss distillation_loss = self.distillation_loss_fn( tf.nn.softmax(teacher_predictions / self.temperature, axis=1), tf.nn.softmax(student_predictions / self.temperature, axis=1), ) # Compute gradients trainable_vars = self.student.trainable_variables gradients = tape.gradient(distillation_loss, trainable_vars) # Update weights self.optimizer.apply_gradients(zip(gradients, trainable_vars)) # Report progress self.loss_tracker.update_state(distillation_loss) return {\"distillation_loss\": self.loss_tracker.result()} def test_step(self, data): # Unpack data x, y = data # Forward passes teacher_predictions = self.teacher(x, training=False) student_predictions = self.student(x, training=False) # Calculate the loss distillation_loss = self.distillation_loss_fn( tf.nn.softmax(teacher_predictions / self.temperature, axis=1), tf.nn.softmax(student_predictions / self.temperature, axis=1), ) # Report progress self.loss_tracker.update_state(distillation_loss) self.compiled_metrics.update_state(y, student_predictions) results = {m.name: m.result() for m in self.metrics} return results Learning rate schedule A warmup cosine learning rate schedule is used in the paper. This schedule is also typical for many pre-training methods especially for computer vision. # Some code is taken from: # https://www.kaggle.com/ashusma/training-rfcx-tensorflow-tpu-effnet-b2. class WarmUpCosine(keras.optimizers.schedules.LearningRateSchedule): def __init__( self, learning_rate_base, total_steps, warmup_learning_rate, warmup_steps ): super(WarmUpCosine, self).__init__() self.learning_rate_base = learning_rate_base self.total_steps = total_steps self.warmup_learning_rate = warmup_learning_rate self.warmup_steps = warmup_steps self.pi = tf.constant(np.pi) def __call__(self, step): if self.total_steps < self.warmup_steps: raise ValueError(\"Total_steps must be larger or equal to warmup_steps.\") cos_annealed_lr = tf.cos( self.pi * (tf.cast(step, tf.float32) - self.warmup_steps) / float(self.total_steps - self.warmup_steps) ) learning_rate = 0.5 * self.learning_rate_base * (1 + cos_annealed_lr) if self.warmup_steps > 0: if self.learning_rate_base < self.warmup_learning_rate: raise ValueError( \"Learning_rate_base must be larger or equal to \" \"warmup_learning_rate.\" ) slope = ( self.learning_rate_base - self.warmup_learning_rate ) / self.warmup_steps warmup_rate = slope * tf.cast(step, tf.float32) + self.warmup_learning_rate learning_rate = tf.where( step < self.warmup_steps, warmup_rate, learning_rate ) return tf.where( step > self.total_steps, 0.0, learning_rate, name=\"learning_rate\" ) We can now plot a a graph of learning rates generated using this schedule. ARTIFICIAL_EPOCHS = 1000 ARTIFICIAL_BATCH_SIZE = 512 DATASET_NUM_TRAIN_EXAMPLES = 1020 TOTAL_STEPS = int( DATASET_NUM_TRAIN_EXAMPLES / ARTIFICIAL_BATCH_SIZE * ARTIFICIAL_EPOCHS ) scheduled_lrs = WarmUpCosine( learning_rate_base=INIT_LR, total_steps=TOTAL_STEPS, warmup_learning_rate=0.0, warmup_steps=1500, ) lrs = [scheduled_lrs(step) for step in range(TOTAL_STEPS)] plt.plot(lrs) plt.xlabel(\"Step\", fontsize=14) plt.ylabel(\"LR\", fontsize=14) plt.show() png The original paper uses at least 1000 epochs and a batch size of 512 to perform \"function matching\". The objective of this example is to present a workflow to implement the recipe and not to demonstrate the results when they are applied at full scale. However, these recipes will transfer to the original settings from the paper. Please refer to this repository if you are interested in finding out more. Training optimizer = tfa.optimizers.AdamW( weight_decay=WEIGHT_DECAY, learning_rate=scheduled_lrs, clipnorm=CLIP_THRESHOLD ) student_model = get_resnetv2() distiller = Distiller(student=student_model, teacher=teacher_model) distiller.compile( optimizer, metrics=[keras.metrics.SparseCategoricalAccuracy()], distillation_loss_fn=keras.losses.KLDivergence(), temperature=TEMPERATURE, ) history = distiller.fit( train_ds, steps_per_epoch=int(np.ceil(DATASET_NUM_TRAIN_EXAMPLES / BATCH_SIZE)), validation_data=validation_ds, epochs=30, # This should be at least 1000. ) student = distiller.student student_model.compile(metrics=[\"accuracy\"]) _, top1_accuracy = student.evaluate(test_ds) print(f\"Top-1 accuracy on the test set: {round(top1_accuracy * 100, 2)}%\") Epoch 1/30 16/16 [==============================] - 74s 3s/step - distillation_loss: 0.0070 - val_sparse_categorical_accuracy: 0.0039 - val_distillation_loss: 0.0061 Epoch 2/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0059 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0061 Epoch 3/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0049 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0060 Epoch 4/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0048 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0060 Epoch 5/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0043 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0060 Epoch 6/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0041 - val_sparse_categorical_accuracy: 0.0108 - val_distillation_loss: 0.0060 Epoch 7/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0038 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0061 Epoch 8/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0040 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0062 Epoch 9/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0039 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0063 Epoch 10/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0035 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0064 Epoch 11/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0041 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0064 Epoch 12/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0039 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0067 Epoch 13/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0039 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0067 Epoch 14/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0036 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0066 Epoch 15/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0037 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0065 Epoch 16/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0038 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0068 Epoch 17/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0039 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0066 Epoch 18/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0038 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0064 Epoch 19/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0035 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0071 Epoch 20/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0038 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0066 Epoch 21/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0038 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0068 Epoch 22/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0034 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0073 Epoch 23/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0035 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0078 Epoch 24/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0037 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0087 Epoch 25/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0031 - val_sparse_categorical_accuracy: 0.0108 - val_distillation_loss: 0.0078 Epoch 26/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0033 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0072 Epoch 27/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0036 - val_sparse_categorical_accuracy: 0.0098 - val_distillation_loss: 0.0071 Epoch 28/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0036 - val_sparse_categorical_accuracy: 0.0275 - val_distillation_loss: 0.0078 Epoch 29/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0032 - val_sparse_categorical_accuracy: 0.0196 - val_distillation_loss: 0.0068 Epoch 30/30 16/16 [==============================] - 37s 2s/step - distillation_loss: 0.0034 - val_sparse_categorical_accuracy: 0.0147 - val_distillation_loss: 0.0071 97/97 [==============================] - 7s 64ms/step - loss: 0.0000e+00 - accuracy: 0.0107 Top-1 accuracy on the test set: 1.07% Results With just 30 epochs of training, the results are nowhere near expected. This is where the benefits of patience aka a longer training schedule will come into play. Let's investigate what the model trained for 1000 epochs can do. # Download the pre-trained weights. !wget https://git.io/JBO3Y -O S-r50x1-128-1000.tar.gz !tar xf S-r50x1-128-1000.tar.gz pretrained_student = keras.models.load_model(\"S-r50x1-128-1000\") pretrained_student.summary() Model: \"resnet\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= root_block (Sequential) (None, 32, 32, 64) 9408 _________________________________________________________________ block1 (Sequential) (None, 32, 32, 256) 214912 _________________________________________________________________ block2 (Sequential) (None, 16, 16, 512) 1218048 _________________________________________________________________ block3 (Sequential) (None, 8, 8, 1024) 7095296 _________________________________________________________________ block4 (Sequential) (None, 4, 4, 2048) 14958592 _________________________________________________________________ group_norm (GroupNormalizati multiple 4096 _________________________________________________________________ re_lu_97 (ReLU) multiple 0 _________________________________________________________________ global_average_pooling2d_1 ( multiple 0 _________________________________________________________________ head/dense (Dense) multiple 208998 ================================================================= Total params: 23,709,350 Trainable params: 23,709,350 Non-trainable params: 0 _________________________________________________________________ This model exactly follows what the authors have used in their student models. This is why the model summary is a bit different. _, top1_accuracy = pretrained_student.evaluate(test_ds) print(f\"Top-1 accuracy on the test set: {round(top1_accuracy * 100, 2)}%\") 97/97 [==============================] - 14s 131ms/step - loss: 0.0000e+00 - accuracy: 0.8102 Top-1 accuracy on the test set: 81.02% With 100000 epochs of training, this same model leads to a top-1 accuracy of 95.54%. There are a number of important ablations studies presented in the paper that show the effectiveness of these recipes compared to the prior art. So if you are skeptical about these recipes, definitely consult the paper. Note on training for longer With TPU-based hardware infrastructure, we can train the model for 1000 epochs faster. This does not even require adding a lot of changes to this codebase. You are encouraged to check this repository as it presents TPU-compatible training workflows for these recipes and can be run on Kaggle Kernel leveraging their free TPU v3-8 hardware. Using compositional and mixed-dimension embeddings for memory-efficient recommendation models. Introduction This example demonstrates two techniques for building memory-efficient recommendation models by reducing the size of the embedding tables, without sacrificing model effectiveness: Quotient-remainder trick, by Hao-Jun Michael Shi et al., which reduces the number of embedding vectors to store, yet produces unique embedding vector for each item without explicit definition. Mixed Dimension embeddings, by Antonio Ginart et al., which stores embedding vectors with mixed dimensions, where less popular items have reduced dimension embeddings. We use the 1M version of the Movielens dataset. The dataset includes around 1 million ratings from 6,000 users on 4,000 movies. Setup import os import math from zipfile import ZipFile from urllib.request import urlretrieve import numpy as np import pandas as pd import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.layers import StringLookup import matplotlib.pyplot as plt Prepare the data Download and process data urlretrieve(\"http://files.grouplens.org/datasets/movielens/ml-1m.zip\", \"movielens.zip\") ZipFile(\"movielens.zip\", \"r\").extractall() ratings_data = pd.read_csv( \"ml-1m/ratings.dat\", sep=\"::\", names=[\"user_id\", \"movie_id\", \"rating\", \"unix_timestamp\"], ) ratings_data[\"movie_id\"] = ratings_data[\"movie_id\"].apply(lambda x: f\"movie_{x}\") ratings_data[\"user_id\"] = ratings_data[\"user_id\"].apply(lambda x: f\"user_{x}\") ratings_data[\"rating\"] = ratings_data[\"rating\"].apply(lambda x: float(x)) del ratings_data[\"unix_timestamp\"] print(f\"Number of users: {len(ratings_data.user_id.unique())}\") print(f\"Number of movies: {len(ratings_data.movie_id.unique())}\") print(f\"Number of ratings: {len(ratings_data.index)}\") Number of users: 6040 Number of movies: 3706 Number of ratings: 1000209 Create train and eval data splits random_selection = np.random.rand(len(ratings_data.index)) <= 0.85 train_data = ratings_data[random_selection] eval_data = ratings_data[~random_selection] train_data.to_csv(\"train_data.csv\", index=False, sep=\"|\", header=False) eval_data.to_csv(\"eval_data.csv\", index=False, sep=\"|\", header=False) print(f\"Train data split: {len(train_data.index)}\") print(f\"Eval data split: {len(eval_data.index)}\") print(\"Train and eval data files are saved.\") Train data split: 850361 Eval data split: 149848 Train and eval data files are saved. Define dataset metadata and hyperparameters csv_header = list(ratings_data.columns) user_vocabulary = list(ratings_data.user_id.unique()) movie_vocabulary = list(ratings_data.movie_id.unique()) target_feature_name = \"rating\" learning_rate = 0.001 batch_size = 128 num_epochs = 3 base_embedding_dim = 64 Train and evaluate the model def get_dataset_from_csv(csv_file_path, batch_size=128, shuffle=True): return tf.data.experimental.make_csv_dataset( csv_file_path, batch_size=batch_size, column_names=csv_header, label_name=target_feature_name, num_epochs=1, header=False, field_delim=\"|\", shuffle=shuffle, ) def run_experiment(model): # Compile the model. model.compile( optimizer=keras.optimizers.Adam(learning_rate), loss=tf.keras.losses.MeanSquaredError(), metrics=[keras.metrics.MeanAbsoluteError(name=\"mae\")], ) # Read the training data. train_dataset = get_dataset_from_csv(\"train_data.csv\", batch_size) # Read the test data. eval_dataset = get_dataset_from_csv(\"eval_data.csv\", batch_size, shuffle=False) # Fit the model with the training data. history = model.fit(train_dataset, epochs=num_epochs, validation_data=eval_dataset,) return history Experiment 1: baseline collaborative filtering model Implement embedding encoder def embedding_encoder(vocabulary, embedding_dim, num_oov_indices=0, name=None): return keras.Sequential( [ StringLookup( vocabulary=vocabulary, mask_token=None, num_oov_indices=num_oov_indices ), layers.Embedding( input_dim=len(vocabulary) + num_oov_indices, output_dim=embedding_dim ), ], name=f\"{name}_embedding\" if name else None, ) Implement the baseline model def create_baseline_model(): # Receive the user as an input. user_input = layers.Input(name=\"user_id\", shape=(), dtype=tf.string) # Get user embedding. user_embedding = embedding_encoder( vocabulary=user_vocabulary, embedding_dim=base_embedding_dim, name=\"user\" )(user_input) # Receive the movie as an input. movie_input = layers.Input(name=\"movie_id\", shape=(), dtype=tf.string) # Get embedding. movie_embedding = embedding_encoder( vocabulary=movie_vocabulary, embedding_dim=base_embedding_dim, name=\"movie\" )(movie_input) # Compute dot product similarity between user and movie embeddings. logits = layers.Dot(axes=1, name=\"dot_similarity\")( [user_embedding, movie_embedding] ) # Convert to rating scale. prediction = keras.activations.sigmoid(logits) * 5 # Create the model. model = keras.Model( inputs=[user_input, movie_input], outputs=prediction, name=\"baseline_model\" ) return model baseline_model = create_baseline_model() baseline_model.summary() Model: \"baseline_model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== user_id (InputLayer) [(None,)] 0 __________________________________________________________________________________________________ movie_id (InputLayer) [(None,)] 0 __________________________________________________________________________________________________ user_embedding (Sequential) (None, 64) 386560 user_id[0][0] __________________________________________________________________________________________________ movie_embedding (Sequential) (None, 64) 237184 movie_id[0][0] __________________________________________________________________________________________________ dot_similarity (Dot) (None, 1) 0 user_embedding[0][0] movie_embedding[0][0] __________________________________________________________________________________________________ tf.math.sigmoid (TFOpLambda) (None, 1) 0 dot_similarity[0][0] __________________________________________________________________________________________________ tf.math.multiply (TFOpLambda) (None, 1) 0 tf.math.sigmoid[0][0] ================================================================================================== Total params: 623,744 Trainable params: 623,744 Non-trainable params: 0 __________________________________________________________________________________________________ Notice that the number of trainable parameters is 623,744 history = run_experiment(baseline_model) plt.plot(history.history[\"loss\"]) plt.plot(history.history[\"val_loss\"]) plt.title(\"model loss\") plt.ylabel(\"loss\") plt.xlabel(\"epoch\") plt.legend([\"train\", \"eval\"], loc=\"upper left\") plt.show() Epoch 1/3 6644/6644 [==============================] - 46s 7ms/step - loss: 1.4399 - mae: 0.9818 - val_loss: 0.9348 - val_mae: 0.7569 Epoch 2/3 6644/6644 [==============================] - 53s 8ms/step - loss: 0.8422 - mae: 0.7246 - val_loss: 0.7991 - val_mae: 0.7076 Epoch 3/3 6644/6644 [==============================] - 58s 9ms/step - loss: 0.7461 - mae: 0.6819 - val_loss: 0.7564 - val_mae: 0.6869 png Experiment 2: memory-efficient model Implement Quotient-Remainder embedding as a layer The Quotient-Remainder technique works as follows. For a set of vocabulary and embedding size embedding_dim, instead of creating a vocabulary_size X embedding_dim embedding table, we create two num_buckets X embedding_dim embedding tables, where num_buckets is much smaller than vocabulary_size. An embedding for a given item index is generated via the following steps: Compute the quotient_index as index // num_buckets. Compute the remainder_index as index % num_buckets. Lookup quotient_embedding from the first embedding table using quotient_index. Lookup remainder_embedding from the second embedding table using remainder_index. Return quotient_embedding * remainder_embedding. This technique not only reduces the number of embedding vectors needs to be stored and trained, but also generates a unique embedding vector for each item of size embedding_dim. Note that q_embedding and r_embedding can be combined using other operations, like Add and Concatenate. class QREmbedding(keras.layers.Layer): def __init__(self, vocabulary, embedding_dim, num_buckets, name=None): super(QREmbedding, self).__init__(name=name) self.num_buckets = num_buckets self.index_lookup = StringLookup( vocabulary=vocabulary, mask_token=None, num_oov_indices=0 ) self.q_embeddings = layers.Embedding(num_buckets, embedding_dim,) self.r_embeddings = layers.Embedding(num_buckets, embedding_dim,) def call(self, inputs): # Get the item index. embedding_index = self.index_lookup(inputs) # Get the quotient index. quotient_index = tf.math.floordiv(embedding_index, self.num_buckets) # Get the reminder index. remainder_index = tf.math.floormod(embedding_index, self.num_buckets) # Lookup the quotient_embedding using the quotient_index. quotient_embedding = self.q_embeddings(quotient_index) # Lookup the remainder_embedding using the remainder_index. remainder_embedding = self.r_embeddings(remainder_index) # Use multiplication as a combiner operation return quotient_embedding * remainder_embedding Implement Mixed Dimension embedding as a layer In the mixed dimension embedding technique, we train embedding vectors with full dimensions for the frequently queried items, while train embedding vectors with reduced dimensions for less frequent items, plus a projection weights matrix to bring low dimension embeddings to the full dimensions. More precisely, we define blocks of items of similar frequencies. For each block, a block_vocab_size X block_embedding_dim embedding table and block_embedding_dim X full_embedding_dim projection weights matrix are created. Note that, if block_embedding_dim equals full_embedding_dim, the projection weights matrix becomes an identity matrix. Embeddings for a given batch of item indices are generated via the following steps: For each block, lookup the block_embedding_dim embedding vectors using indices, and project them to the full_embedding_dim. If an item index does not belong to a given block, an out-of-vocabulary embedding is returned. Each block will return a batch_size X full_embedding_dim tensor. A mask is applied to the embeddings returned from each block in order to convert the out-of-vocabulary embeddings to vector of zeros. That is, for each item in the batch, a single non-zero embedding vector is returned from the all block embeddings. Embeddings retrieved from the blocks are combined using sum to produce the final batch_size X full_embedding_dim tensor. class MDEmbedding(keras.layers.Layer): def __init__( self, blocks_vocabulary, blocks_embedding_dims, base_embedding_dim, name=None ): super(MDEmbedding, self).__init__(name=name) self.num_blocks = len(blocks_vocabulary) # Create vocab to block lookup. keys = [] values = [] for block_idx, block_vocab in enumerate(blocks_vocabulary): keys.extend(block_vocab) values.extend([block_idx] * len(block_vocab)) self.vocab_to_block = tf.lookup.StaticHashTable( tf.lookup.KeyValueTensorInitializer(keys, values), default_value=-1 ) self.block_embedding_encoders = [] self.block_embedding_projectors = [] # Create block embedding encoders and projectors. for idx in range(self.num_blocks): vocabulary = blocks_vocabulary[idx] embedding_dim = blocks_embedding_dims[idx] block_embedding_encoder = embedding_encoder( vocabulary, embedding_dim, num_oov_indices=1 ) self.block_embedding_encoders.append(block_embedding_encoder) if embedding_dim == base_embedding_dim: self.block_embedding_projectors.append(layers.Lambda(lambda x: x)) else: self.block_embedding_projectors.append( layers.Dense(units=base_embedding_dim) ) def call(self, inputs): # Get block index for each input item. block_indicies = self.vocab_to_block.lookup(inputs) # Initialize output embeddings to zeros. embeddings = tf.zeros(shape=(tf.shape(inputs)[0], base_embedding_dim)) # Generate embeddings from blocks. for idx in range(self.num_blocks): # Lookup embeddings from the current block. block_embeddings = self.block_embedding_encoders[idx](inputs) # Project embeddings to base_embedding_dim. block_embeddings = self.block_embedding_projectors[idx](block_embeddings) # Create a mask to filter out embeddings of items that do not belong to the current block. mask = tf.expand_dims(tf.cast(block_indicies == idx, tf.dtypes.float32), 1) # Set the embeddings for the items not belonging to the current block to zeros. block_embeddings = block_embeddings * mask # Add the block embeddings to the final embeddings. embeddings += block_embeddings return embeddings Implement the memory-efficient model In this experiment, we are going to use the Quotient-Remainder technique to reduce the size of the user embeddings, and the Mixed Dimension technique to reduce the size of the movie embeddings. While in the paper, an alpha-power rule is used to determined the dimensions of the embedding of each block, we simply set the number of blocks and the dimensions of embeddings of each block based on the histogram visualization of movies popularity. movie_frequencies = ratings_data[\"movie_id\"].value_counts() movie_frequencies.hist(bins=10) png You can see that we can group the movies into three blocks, and assign them 64, 32, and 16 embedding dimensions, respectively. Feel free to experiment with different number of blocks and dimensions. sorted_movie_vocabulary = list(movie_frequencies.keys()) movie_blocks_vocabulary = [ sorted_movie_vocabulary[:400], # high popularity movies block sorted_movie_vocabulary[400:1700], # normal popularity movies block sorted_movie_vocabulary[1700:], # low popularity movies block ] movie_blocks_embedding_dims = [64, 32, 16] user_embedding_num_buckets = len(user_vocabulary) // 50 def create_memory_efficient_model(): # Take the user as an input. user_input = layers.Input(name=\"user_id\", shape=(), dtype=tf.string) # Get user embedding. user_embedding = QREmbedding( vocabulary=user_vocabulary, embedding_dim=base_embedding_dim, num_buckets=user_embedding_num_buckets, name=\"user_embedding\", )(user_input) # Take the movie as an input. movie_input = layers.Input(name=\"movie_id\", shape=(), dtype=tf.string) # Get embedding. movie_embedding = MDEmbedding( blocks_vocabulary=movie_blocks_vocabulary, blocks_embedding_dims=movie_blocks_embedding_dims, base_embedding_dim=base_embedding_dim, name=\"movie_embedding\", )(movie_input) # Compute dot product similarity between user and movie embeddings. logits = layers.Dot(axes=1, name=\"dot_similarity\")( [user_embedding, movie_embedding] ) # Convert to rating scale. prediction = keras.activations.sigmoid(logits) * 5 # Create the model. model = keras.Model( inputs=[user_input, movie_input], outputs=prediction, name=\"baseline_model\" ) return model memory_efficient_model = create_memory_efficient_model() memory_efficient_model.summary() Model: \"baseline_model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== user_id (InputLayer) [(None,)] 0 __________________________________________________________________________________________________ movie_id (InputLayer) [(None,)] 0 __________________________________________________________________________________________________ user_embedding (QREmbedding) (None, 64) 15360 user_id[0][0] __________________________________________________________________________________________________ movie_embedding (MDEmbedding) (None, 64) 102608 movie_id[0][0] __________________________________________________________________________________________________ dot_similarity (Dot) (None, 1) 0 user_embedding[0][0] movie_embedding[0][0] __________________________________________________________________________________________________ tf.math.sigmoid_1 (TFOpLambda) (None, 1) 0 dot_similarity[0][0] __________________________________________________________________________________________________ tf.math.multiply_1 (TFOpLambda) (None, 1) 0 tf.math.sigmoid_1[0][0] ================================================================================================== Total params: 117,968 Trainable params: 117,968 Non-trainable params: 0 __________________________________________________________________________________________________ Notice that the number of trainable parameters is 117,968, which is more than 5x less than the number of parameters in the baseline model. history = run_experiment(memory_efficient_model) plt.plot(history.history[\"loss\"]) plt.plot(history.history[\"val_loss\"]) plt.title(\"model loss\") plt.ylabel(\"loss\") plt.xlabel(\"epoch\") plt.legend([\"train\", \"eval\"], loc=\"upper left\") plt.show() Epoch 1/3 6644/6644 [==============================] - 10s 1ms/step - loss: 1.2632 - mae: 0.9078 - val_loss: 1.0593 - val_mae: 0.8045 Epoch 2/3 6644/6644 [==============================] - 9s 1ms/step - loss: 0.8933 - mae: 0.7512 - val_loss: 0.8932 - val_mae: 0.7519 Epoch 3/3 6644/6644 [==============================] - 9s 1ms/step - loss: 0.8412 - mae: 0.7279 - val_loss: 0.8612 - val_mae: 0.7357 png Building Probabilistic Bayesian neural network models with TensorFlow Probability. Introduction Taking a probabilistic approach to deep learning allows to account for uncertainty, so that models can assign less levels of confidence to incorrect predictions. Sources of uncertainty can be found in the data, due to measurement error or noise in the labels, or the model, due to insufficient data availability for the model to learn effectively. This example demonstrates how to build basic probabilistic Bayesian neural networks to account for these two types of uncertainty. We use TensorFlow Probability library, which is compatible with Keras API. This example requires TensorFlow 2.3 or higher. You can install Tensorflow Probability using the following command: pip install tensorflow-probability The dataset We use the Wine Quality dataset, which is available in the TensorFlow Datasets. We use the red wine subset, which contains 4,898 examples. The dataset has 11numerical physicochemical features of the wine, and the task is to predict the wine quality, which is a score between 0 and 10. In this example, we treat this as a regression task. You can install TensorFlow Datasets using the following command: pip install tensorflow-datasets Setup import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import tensorflow_datasets as tfds import tensorflow_probability as tfp Create training and evaluation datasets Here, we load the wine_quality dataset using tfds.load(), and we convert the target feature to float. Then, we shuffle the dataset and split it into training and test sets. We take the first train_size examples as the train split, and the rest as the test split. def get_train_and_test_splits(train_size, batch_size=1): # We prefetch with a buffer the same size as the dataset because th dataset # is very small and fits into memory. dataset = ( tfds.load(name=\"wine_quality\", as_supervised=True, split=\"train\") .map(lambda x, y: (x, tf.cast(y, tf.float32))) .prefetch(buffer_size=dataset_size) .cache() ) # We shuffle with a buffer the same size as the dataset. train_dataset = ( dataset.take(train_size).shuffle(buffer_size=train_size).batch(batch_size) ) test_dataset = dataset.skip(train_size).batch(batch_size) return train_dataset, test_dataset Compile, train, and evaluate the model hidden_units = [8, 8] learning_rate = 0.001 def run_experiment(model, loss, train_dataset, test_dataset): model.compile( optimizer=keras.optimizers.RMSprop(learning_rate=learning_rate), loss=loss, metrics=[keras.metrics.RootMeanSquaredError()], ) print(\"Start training the model...\") model.fit(train_dataset, epochs=num_epochs, validation_data=test_dataset) print(\"Model training finished.\") _, rmse = model.evaluate(train_dataset, verbose=0) print(f\"Train RMSE: {round(rmse, 3)}\") print(\"Evaluating model performance...\") _, rmse = model.evaluate(test_dataset, verbose=0) print(f\"Test RMSE: {round(rmse, 3)}\") Create model inputs FEATURE_NAMES = [ \"fixed acidity\", \"volatile acidity\", \"citric acid\", \"residual sugar\", \"chlorides\", \"free sulfur dioxide\", \"total sulfur dioxide\", \"density\", \"pH\", \"sulphates\", \"alcohol\", ] def create_model_inputs(): inputs = {} for feature_name in FEATURE_NAMES: inputs[feature_name] = layers.Input( name=feature_name, shape=(1,), dtype=tf.float32 ) return inputs Experiment 1: standard neural network We create a standard deterministic neural network model as a baseline. def create_baseline_model(): inputs = create_model_inputs() input_values = [value for _, value in sorted(inputs.items())] features = keras.layers.concatenate(input_values) features = layers.BatchNormalization()(features) # Create hidden layers with deterministic weights using the Dense layer. for units in hidden_units: features = layers.Dense(units, activation=\"sigmoid\")(features) # The output is deterministic: a single point estimate. outputs = layers.Dense(units=1)(features) model = keras.Model(inputs=inputs, outputs=outputs) return model Let's split the wine dataset into training and test sets, with 85% and 15% of the examples, respectively. dataset_size = 4898 batch_size = 256 train_size = int(dataset_size * 0.85) train_dataset, test_dataset = get_train_and_test_splits(train_size, batch_size) Now let's train the baseline model. We use the MeanSquaredError as the loss function. num_epochs = 100 mse_loss = keras.losses.MeanSquaredError() baseline_model = create_baseline_model() run_experiment(baseline_model, mse_loss, train_dataset, test_dataset) Start training the model... Epoch 1/100 17/17 [==============================] - 1s 53ms/step - loss: 37.5710 - root_mean_squared_error: 6.1294 - val_loss: 35.6750 - val_root_mean_squared_error: 5.9729 Epoch 2/100 17/17 [==============================] - 0s 7ms/step - loss: 35.5154 - root_mean_squared_error: 5.9594 - val_loss: 34.2430 - val_root_mean_squared_error: 5.8518 Epoch 3/100 17/17 [==============================] - 0s 7ms/step - loss: 33.9975 - root_mean_squared_error: 5.8307 - val_loss: 32.8003 - val_root_mean_squared_error: 5.7272 Epoch 4/100 17/17 [==============================] - 0s 12ms/step - loss: 32.5928 - root_mean_squared_error: 5.7090 - val_loss: 31.3385 - val_root_mean_squared_error: 5.5981 Epoch 5/100 17/17 [==============================] - 0s 7ms/step - loss: 30.8914 - root_mean_squared_error: 5.5580 - val_loss: 29.8659 - val_root_mean_squared_error: 5.4650 ... Epoch 95/100 17/17 [==============================] - 0s 6ms/step - loss: 0.6927 - root_mean_squared_error: 0.8322 - val_loss: 0.6901 - val_root_mean_squared_error: 0.8307 Epoch 96/100 17/17 [==============================] - 0s 6ms/step - loss: 0.6929 - root_mean_squared_error: 0.8323 - val_loss: 0.6866 - val_root_mean_squared_error: 0.8286 Epoch 97/100 17/17 [==============================] - 0s 6ms/step - loss: 0.6582 - root_mean_squared_error: 0.8112 - val_loss: 0.6797 - val_root_mean_squared_error: 0.8244 Epoch 98/100 17/17 [==============================] - 0s 6ms/step - loss: 0.6733 - root_mean_squared_error: 0.8205 - val_loss: 0.6740 - val_root_mean_squared_error: 0.8210 Epoch 99/100 17/17 [==============================] - 0s 7ms/step - loss: 0.6623 - root_mean_squared_error: 0.8138 - val_loss: 0.6713 - val_root_mean_squared_error: 0.8193 Epoch 100/100 17/17 [==============================] - 0s 6ms/step - loss: 0.6522 - root_mean_squared_error: 0.8075 - val_loss: 0.6666 - val_root_mean_squared_error: 0.8165 Model training finished. Train RMSE: 0.809 Evaluating model performance... Test RMSE: 0.816 We take a sample from the test set use the model to obtain predictions for them. Note that since the baseline model is deterministic, we get a single a point estimate prediction for each test example, with no information about the uncertainty of the model nor the prediction. sample = 10 examples, targets = list(test_dataset.unbatch().shuffle(batch_size * 10).batch(sample))[ 0 ] predicted = baseline_model(examples).numpy() for idx in range(sample): print(f\"Predicted: {round(float(predicted[idx][0]), 1)} - Actual: {targets[idx]}\") Predicted: 6.0 - Actual: 6.0 Predicted: 6.2 - Actual: 6.0 Predicted: 5.8 - Actual: 7.0 Predicted: 6.0 - Actual: 5.0 Predicted: 5.7 - Actual: 5.0 Predicted: 6.2 - Actual: 7.0 Predicted: 5.6 - Actual: 5.0 Predicted: 6.2 - Actual: 6.0 Predicted: 6.2 - Actual: 6.0 Predicted: 6.2 - Actual: 7.0 Experiment 2: Bayesian neural network (BNN) The object of the Bayesian approach for modeling neural networks is to capture the epistemic uncertainty, which is uncertainty about the model fitness, due to limited training data. The idea is that, instead of learning specific weight (and bias) values in the neural network, the Bayesian approach learns weight distributions - from which we can sample to produce an output for a given input - to encode weight uncertainty. Thus, we need to define prior and the posterior distributions of these weights, and the training process is to learn the parameters of these distributions. # Define the prior weight distribution as Normal of mean=0 and stddev=1. # Note that, in this example, the we prior distribution is not trainable, # as we fix its parameters. def prior(kernel_size, bias_size, dtype=None): n = kernel_size + bias_size prior_model = keras.Sequential( [ tfp.layers.DistributionLambda( lambda t: tfp.distributions.MultivariateNormalDiag( loc=tf.zeros(n), scale_diag=tf.ones(n) ) ) ] ) return prior_model # Define variational posterior weight distribution as multivariate Gaussian. # Note that the learnable parameters for this distribution are the means, # variances, and covariances. def posterior(kernel_size, bias_size, dtype=None): n = kernel_size + bias_size posterior_model = keras.Sequential( [ tfp.layers.VariableLayer( tfp.layers.MultivariateNormalTriL.params_size(n), dtype=dtype ), tfp.layers.MultivariateNormalTriL(n), ] ) return posterior_model We use the tfp.layers.DenseVariational layer instead of the standard keras.layers.Dense layer in the neural network model. def create_bnn_model(train_size): inputs = create_model_inputs() features = keras.layers.concatenate(list(inputs.values())) features = layers.BatchNormalization()(features) # Create hidden layers with weight uncertainty using the DenseVariational layer. for units in hidden_units: features = tfp.layers.DenseVariational( units=units, make_prior_fn=prior, make_posterior_fn=posterior, kl_weight=1 / train_size, activation=\"sigmoid\", )(features) # The output is deterministic: a single point estimate. outputs = layers.Dense(units=1)(features) model = keras.Model(inputs=inputs, outputs=outputs) return model The epistemic uncertainty can be reduced as we increase the size of the training data. That is, the more data the BNN model sees, the more it is certain about its estimates for the weights (distribution parameters). Let's test this behaviour by training the BNN model on a small subset of the training set, and then on the full training set, to compare the output variances. Train BNN with a small training subset. num_epochs = 500 train_sample_size = int(train_size * 0.3) small_train_dataset = train_dataset.unbatch().take(train_sample_size).batch(batch_size) bnn_model_small = create_bnn_model(train_sample_size) run_experiment(bnn_model_small, mse_loss, small_train_dataset, test_dataset) Start training the model... Epoch 1/500 5/5 [==============================] - 2s 123ms/step - loss: 34.5497 - root_mean_squared_error: 5.8764 - val_loss: 37.1164 - val_root_mean_squared_error: 6.0910 Epoch 2/500 5/5 [==============================] - 0s 28ms/step - loss: 36.0738 - root_mean_squared_error: 6.0007 - val_loss: 31.7373 - val_root_mean_squared_error: 5.6322 Epoch 3/500 5/5 [==============================] - 0s 29ms/step - loss: 33.3177 - root_mean_squared_error: 5.7700 - val_loss: 36.2135 - val_root_mean_squared_error: 6.0164 Epoch 4/500 5/5 [==============================] - 0s 30ms/step - loss: 35.1247 - root_mean_squared_error: 5.9232 - val_loss: 35.6158 - val_root_mean_squared_error: 5.9663 Epoch 5/500 5/5 [==============================] - 0s 23ms/step - loss: 34.7653 - root_mean_squared_error: 5.8936 - val_loss: 34.3038 - val_root_mean_squared_error: 5.8556 ... Epoch 495/500 5/5 [==============================] - 0s 24ms/step - loss: 0.6978 - root_mean_squared_error: 0.8162 - val_loss: 0.6258 - val_root_mean_squared_error: 0.7723 Epoch 496/500 5/5 [==============================] - 0s 22ms/step - loss: 0.6448 - root_mean_squared_error: 0.7858 - val_loss: 0.6372 - val_root_mean_squared_error: 0.7808 Epoch 497/500 5/5 [==============================] - 0s 23ms/step - loss: 0.6871 - root_mean_squared_error: 0.8121 - val_loss: 0.6437 - val_root_mean_squared_error: 0.7825 Epoch 498/500 5/5 [==============================] - 0s 23ms/step - loss: 0.6213 - root_mean_squared_error: 0.7690 - val_loss: 0.6581 - val_root_mean_squared_error: 0.7922 Epoch 499/500 5/5 [==============================] - 0s 22ms/step - loss: 0.6604 - root_mean_squared_error: 0.7913 - val_loss: 0.6522 - val_root_mean_squared_error: 0.7908 Epoch 500/500 5/5 [==============================] - 0s 22ms/step - loss: 0.6190 - root_mean_squared_error: 0.7678 - val_loss: 0.6734 - val_root_mean_squared_error: 0.8037 Model training finished. Train RMSE: 0.805 Evaluating model performance... Test RMSE: 0.801 Since we have trained a BNN model, the model produces a different output each time we call it with the same input, since each time a new set of weights are sampled from the distributions to construct the network and produce an output. The less certain the mode weights are, the more variability (wider range) we will see in the outputs of the same inputs. def compute_predictions(model, iterations=100): predicted = [] for _ in range(iterations): predicted.append(model(examples).numpy()) predicted = np.concatenate(predicted, axis=1) prediction_mean = np.mean(predicted, axis=1).tolist() prediction_min = np.min(predicted, axis=1).tolist() prediction_max = np.max(predicted, axis=1).tolist() prediction_range = (np.max(predicted, axis=1) - np.min(predicted, axis=1)).tolist() for idx in range(sample): print( f\"Predictions mean: {round(prediction_mean[idx], 2)}, \" f\"min: {round(prediction_min[idx], 2)}, \" f\"max: {round(prediction_max[idx], 2)}, \" f\"range: {round(prediction_range[idx], 2)} - \" f\"Actual: {targets[idx]}\" ) compute_predictions(bnn_model_small) Predictions mean: 5.63, min: 4.92, max: 6.15, range: 1.23 - Actual: 6.0 Predictions mean: 6.35, min: 6.01, max: 6.54, range: 0.53 - Actual: 6.0 Predictions mean: 5.65, min: 4.84, max: 6.25, range: 1.41 - Actual: 7.0 Predictions mean: 5.74, min: 5.21, max: 6.25, range: 1.04 - Actual: 5.0 Predictions mean: 5.99, min: 5.26, max: 6.29, range: 1.03 - Actual: 5.0 Predictions mean: 6.26, min: 6.01, max: 6.47, range: 0.46 - Actual: 7.0 Predictions mean: 5.28, min: 4.73, max: 5.86, range: 1.12 - Actual: 5.0 Predictions mean: 6.34, min: 6.06, max: 6.53, range: 0.47 - Actual: 6.0 Predictions mean: 6.23, min: 5.91, max: 6.44, range: 0.53 - Actual: 6.0 Predictions mean: 6.33, min: 6.05, max: 6.54, range: 0.48 - Actual: 7.0 Train BNN with the whole training set. num_epochs = 500 bnn_model_full = create_bnn_model(train_size) run_experiment(bnn_model_full, mse_loss, train_dataset, test_dataset) compute_predictions(bnn_model_full) Start training the model... Epoch 1/500 17/17 [==============================] - 2s 32ms/step - loss: 25.4811 - root_mean_squared_error: 5.0465 - val_loss: 23.8428 - val_root_mean_squared_error: 4.8824 Epoch 2/500 17/17 [==============================] - 0s 7ms/step - loss: 23.0849 - root_mean_squared_error: 4.8040 - val_loss: 24.1269 - val_root_mean_squared_error: 4.9115 Epoch 3/500 17/17 [==============================] - 0s 7ms/step - loss: 22.5191 - root_mean_squared_error: 4.7449 - val_loss: 23.3312 - val_root_mean_squared_error: 4.8297 Epoch 4/500 17/17 [==============================] - 0s 7ms/step - loss: 22.9571 - root_mean_squared_error: 4.7896 - val_loss: 24.4072 - val_root_mean_squared_error: 4.9399 Epoch 5/500 17/17 [==============================] - 0s 6ms/step - loss: 21.4049 - root_mean_squared_error: 4.6245 - val_loss: 21.1895 - val_root_mean_squared_error: 4.6027 ... Epoch 495/500 17/17 [==============================] - 0s 7ms/step - loss: 0.5799 - root_mean_squared_error: 0.7511 - val_loss: 0.5902 - val_root_mean_squared_error: 0.7572 Epoch 496/500 17/17 [==============================] - 0s 6ms/step - loss: 0.5926 - root_mean_squared_error: 0.7603 - val_loss: 0.5961 - val_root_mean_squared_error: 0.7616 Epoch 497/500 17/17 [==============================] - 0s 7ms/step - loss: 0.5928 - root_mean_squared_error: 0.7595 - val_loss: 0.5916 - val_root_mean_squared_error: 0.7595 Epoch 498/500 17/17 [==============================] - 0s 7ms/step - loss: 0.6115 - root_mean_squared_error: 0.7715 - val_loss: 0.5869 - val_root_mean_squared_error: 0.7558 Epoch 499/500 17/17 [==============================] - 0s 7ms/step - loss: 0.6044 - root_mean_squared_error: 0.7673 - val_loss: 0.6007 - val_root_mean_squared_error: 0.7645 Epoch 500/500 17/17 [==============================] - 0s 7ms/step - loss: 0.5853 - root_mean_squared_error: 0.7550 - val_loss: 0.5999 - val_root_mean_squared_error: 0.7651 Model training finished. Train RMSE: 0.762 Evaluating model performance... Test RMSE: 0.759 Predictions mean: 5.41, min: 5.06, max: 5.9, range: 0.84 - Actual: 6.0 Predictions mean: 6.5, min: 6.16, max: 6.61, range: 0.44 - Actual: 6.0 Predictions mean: 5.59, min: 4.96, max: 6.0, range: 1.04 - Actual: 7.0 Predictions mean: 5.67, min: 5.25, max: 6.01, range: 0.76 - Actual: 5.0 Predictions mean: 6.02, min: 5.68, max: 6.39, range: 0.71 - Actual: 5.0 Predictions mean: 6.35, min: 6.11, max: 6.52, range: 0.41 - Actual: 7.0 Predictions mean: 5.21, min: 4.85, max: 5.68, range: 0.83 - Actual: 5.0 Predictions mean: 6.53, min: 6.35, max: 6.64, range: 0.28 - Actual: 6.0 Predictions mean: 6.3, min: 6.05, max: 6.47, range: 0.42 - Actual: 6.0 Predictions mean: 6.44, min: 6.19, max: 6.59, range: 0.4 - Actual: 7.0 Notice that the model trained with the full training dataset shows smaller range (uncertainty) in the prediction values for the same inputs, compared to the model trained with a subset of the training dataset. Experiment 3: probabilistic Bayesian neural network So far, the output of the standard and the Bayesian NN models that we built is deterministic, that is, produces a point estimate as a prediction for a given example. We can create a probabilistic NN by letting the model output a distribution. In this case, the model captures the aleatoric uncertainty as well, which is due to irreducible noise in the data, or to the stochastic nature of the process generating the data. In this example, we model the output as a IndependentNormal distribution, with learnable mean and variance parameters. If the task was classification, we would have used IndependentBernoulli with binary classes, and OneHotCategorical with multiple classes, to model distribution of the model output. def create_probablistic_bnn_model(train_size): inputs = create_model_inputs() features = keras.layers.concatenate(list(inputs.values())) features = layers.BatchNormalization()(features) # Create hidden layers with weight uncertainty using the DenseVariational layer. for units in hidden_units: features = tfp.layers.DenseVariational( units=units, make_prior_fn=prior, make_posterior_fn=posterior, kl_weight=1 / train_size, activation=\"sigmoid\", )(features) # Create a probabilisticå output (Normal distribution), and use the `Dense` layer # to produce the parameters of the distribution. # We set units=2 to learn both the mean and the variance of the Normal distribution. distribution_params = layers.Dense(units=2)(features) outputs = tfp.layers.IndependentNormal(1)(distribution_params) model = keras.Model(inputs=inputs, outputs=outputs) return model Since the output of the model is a distribution, rather than a point estimate, we use the negative loglikelihood as our loss function to compute how likely to see the true data (targets) from the estimated distribution produced by the model. def negative_loglikelihood(targets, estimated_distribution): return -estimated_distribution.log_prob(targets) num_epochs = 1000 prob_bnn_model = create_probablistic_bnn_model(train_size) run_experiment(prob_bnn_model, negative_loglikelihood, train_dataset, test_dataset) Start training the model... Epoch 1/1000 17/17 [==============================] - 2s 36ms/step - loss: 11.2378 - root_mean_squared_error: 6.6758 - val_loss: 8.5554 - val_root_mean_squared_error: 6.6240 Epoch 2/1000 17/17 [==============================] - 0s 7ms/step - loss: 11.8285 - root_mean_squared_error: 6.5718 - val_loss: 8.2138 - val_root_mean_squared_error: 6.5256 Epoch 3/1000 17/17 [==============================] - 0s 7ms/step - loss: 8.8566 - root_mean_squared_error: 6.5369 - val_loss: 5.8749 - val_root_mean_squared_error: 6.3394 Epoch 4/1000 17/17 [==============================] - 0s 7ms/step - loss: 7.8191 - root_mean_squared_error: 6.3981 - val_loss: 7.6224 - val_root_mean_squared_error: 6.4473 Epoch 5/1000 17/17 [==============================] - 0s 7ms/step - loss: 6.2598 - root_mean_squared_error: 6.4613 - val_loss: 5.9415 - val_root_mean_squared_error: 6.3466 ... Epoch 995/1000 17/17 [==============================] - 0s 7ms/step - loss: 1.1323 - root_mean_squared_error: 1.0431 - val_loss: 1.1553 - val_root_mean_squared_error: 1.1060 Epoch 996/1000 17/17 [==============================] - 0s 7ms/step - loss: 1.1613 - root_mean_squared_error: 1.0686 - val_loss: 1.1554 - val_root_mean_squared_error: 1.0370 Epoch 997/1000 17/17 [==============================] - 0s 7ms/step - loss: 1.1351 - root_mean_squared_error: 1.0628 - val_loss: 1.1472 - val_root_mean_squared_error: 1.0813 Epoch 998/1000 17/17 [==============================] - 0s 7ms/step - loss: 1.1324 - root_mean_squared_error: 1.0858 - val_loss: 1.1527 - val_root_mean_squared_error: 1.0578 Epoch 999/1000 17/17 [==============================] - 0s 7ms/step - loss: 1.1591 - root_mean_squared_error: 1.0801 - val_loss: 1.1483 - val_root_mean_squared_error: 1.0442 Epoch 1000/1000 17/17 [==============================] - 0s 7ms/step - loss: 1.1402 - root_mean_squared_error: 1.0554 - val_loss: 1.1495 - val_root_mean_squared_error: 1.0389 Model training finished. Train RMSE: 1.068 Evaluating model performance... Test RMSE: 1.068 Now let's produce an output from the model given the test examples. The output is now a distribution, and we can use its mean and variance to compute the confidence intervals (CI) of the prediction. prediction_distribution = prob_bnn_model(examples) prediction_mean = prediction_distribution.mean().numpy().tolist() prediction_stdv = prediction_distribution.stddev().numpy() # The 95% CI is computed as mean ± (1.96 * stdv) upper = (prediction_mean + (1.96 * prediction_stdv)).tolist() lower = (prediction_mean - (1.96 * prediction_stdv)).tolist() prediction_stdv = prediction_stdv.tolist() for idx in range(sample): print( f\"Prediction mean: {round(prediction_mean[idx][0], 2)}, \" f\"stddev: {round(prediction_stdv[idx][0], 2)}, \" f\"95% CI: [{round(upper[idx][0], 2)} - {round(lower[idx][0], 2)}]\" f\" - Actual: {targets[idx]}\" ) Prediction mean: 5.29, stddev: 0.66, 95% CI: [6.58 - 4.0] - Actual: 6.0 Prediction mean: 6.49, stddev: 0.81, 95% CI: [8.08 - 4.89] - Actual: 6.0 Prediction mean: 5.85, stddev: 0.7, 95% CI: [7.22 - 4.48] - Actual: 7.0 Prediction mean: 5.59, stddev: 0.69, 95% CI: [6.95 - 4.24] - Actual: 5.0 Prediction mean: 6.37, stddev: 0.87, 95% CI: [8.07 - 4.67] - Actual: 5.0 Prediction mean: 6.34, stddev: 0.78, 95% CI: [7.87 - 4.81] - Actual: 7.0 Prediction mean: 5.14, stddev: 0.65, 95% CI: [6.4 - 3.87] - Actual: 5.0 Prediction mean: 6.49, stddev: 0.81, 95% CI: [8.09 - 4.89] - Actual: 6.0 Prediction mean: 6.25, stddev: 0.77, 95% CI: [7.76 - 4.74] - Actual: 6.0 Prediction mean: 6.39, stddev: 0.78, 95% CI: [7.92 - 4.85] - Actual: 7.0 Demonstration of custom layer creation. Introduction This example shows how to create custom layers, using the Antirectifier layer (originally proposed as a Keras example script in January 2016), an alternative to ReLU. Instead of zeroing-out the negative part of the input, it splits the negative and positive parts and returns the concatenation of the absolute value of both. This avoids loss of information, at the cost of an increase in dimensionality. To fix the dimensionality increase, we linearly combine the features back to a space of the original size. Setup import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers The Antirectifier layer class Antirectifier(layers.Layer): def __init__(self, initializer=\"he_normal\", **kwargs): super(Antirectifier, self).__init__(**kwargs) self.initializer = keras.initializers.get(initializer) def build(self, input_shape): output_dim = input_shape[-1] self.kernel = self.add_weight( shape=(output_dim * 2, output_dim), initializer=self.initializer, name=\"kernel\", trainable=True, ) def call(self, inputs): inputs -= tf.reduce_mean(inputs, axis=-1, keepdims=True) pos = tf.nn.relu(inputs) neg = tf.nn.relu(-inputs) concatenated = tf.concat([pos, neg], axis=-1) mixed = tf.matmul(concatenated, self.kernel) return mixed def get_config(self): # Implement get_config to enable serialization. This is optional. base_config = super(Antirectifier, self).get_config() config = {\"initializer\": keras.initializers.serialize(self.initializer)} return dict(list(base_config.items()) + list(config.items())) Let's test-drive it on MNIST # Training parameters batch_size = 128 num_classes = 10 epochs = 20 # The data, split between train and test sets (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() x_train = x_train.reshape(-1, 784) x_test = x_test.reshape(-1, 784) x_train = x_train.astype(\"float32\") x_test = x_test.astype(\"float32\") x_train /= 255 x_test /= 255 print(x_train.shape[0], \"train samples\") print(x_test.shape[0], \"test samples\") # Build the model model = keras.Sequential( [ keras.Input(shape=(784,)), layers.Dense(256), Antirectifier(), layers.Dense(256), Antirectifier(), layers.Dropout(0.5), layers.Dense(10), ] ) # Compile the model model.compile( loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), optimizer=keras.optimizers.RMSprop(), metrics=[keras.metrics.SparseCategoricalAccuracy()], ) # Train the model model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.15) # Test the model model.evaluate(x_test, y_test) 60000 train samples 10000 test samples Epoch 1/20 399/399 [==============================] - 2s 5ms/step - loss: 0.3827 - sparse_categorical_accuracy: 0.8882 - val_loss: 0.1407 - val_sparse_categorical_accuracy: 0.9587 Epoch 2/20 399/399 [==============================] - 2s 5ms/step - loss: 0.1771 - sparse_categorical_accuracy: 0.9513 - val_loss: 0.1337 - val_sparse_categorical_accuracy: 0.9674 Epoch 3/20 399/399 [==============================] - 2s 5ms/step - loss: 0.1400 - sparse_categorical_accuracy: 0.9620 - val_loss: 0.1225 - val_sparse_categorical_accuracy: 0.9709 Epoch 4/20 399/399 [==============================] - 2s 5ms/step - loss: 0.1099 - sparse_categorical_accuracy: 0.9707 - val_loss: 0.1465 - val_sparse_categorical_accuracy: 0.9636 Epoch 5/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0996 - sparse_categorical_accuracy: 0.9739 - val_loss: 0.1703 - val_sparse_categorical_accuracy: 0.9626 Epoch 6/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0860 - sparse_categorical_accuracy: 0.9774 - val_loss: 0.1354 - val_sparse_categorical_accuracy: 0.9712 Epoch 7/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0833 - sparse_categorical_accuracy: 0.9791 - val_loss: 0.2018 - val_sparse_categorical_accuracy: 0.9574 Epoch 8/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0712 - sparse_categorical_accuracy: 0.9814 - val_loss: 0.1527 - val_sparse_categorical_accuracy: 0.9723 Epoch 9/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0710 - sparse_categorical_accuracy: 0.9827 - val_loss: 0.1613 - val_sparse_categorical_accuracy: 0.9694 Epoch 10/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0633 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.1463 - val_sparse_categorical_accuracy: 0.9758 Epoch 11/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0604 - sparse_categorical_accuracy: 0.9856 - val_loss: 0.1390 - val_sparse_categorical_accuracy: 0.9769 Epoch 12/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0561 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.1761 - val_sparse_categorical_accuracy: 0.9740 Epoch 13/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0589 - sparse_categorical_accuracy: 0.9873 - val_loss: 0.1598 - val_sparse_categorical_accuracy: 0.9769 Epoch 14/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0527 - sparse_categorical_accuracy: 0.9879 - val_loss: 0.1565 - val_sparse_categorical_accuracy: 0.9802 Epoch 15/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0563 - sparse_categorical_accuracy: 0.9878 - val_loss: 0.1970 - val_sparse_categorical_accuracy: 0.9758 Epoch 16/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0525 - sparse_categorical_accuracy: 0.9888 - val_loss: 0.1937 - val_sparse_categorical_accuracy: 0.9757 Epoch 17/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0522 - sparse_categorical_accuracy: 0.9898 - val_loss: 0.1777 - val_sparse_categorical_accuracy: 0.9797 Epoch 18/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0568 - sparse_categorical_accuracy: 0.9894 - val_loss: 0.1831 - val_sparse_categorical_accuracy: 0.9791 Epoch 19/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0526 - sparse_categorical_accuracy: 0.9900 - val_loss: 0.1812 - val_sparse_categorical_accuracy: 0.9782 Epoch 20/20 399/399 [==============================] - 2s 5ms/step - loss: 0.0503 - sparse_categorical_accuracy: 0.9902 - val_loss: 0.2098 - val_sparse_categorical_accuracy: 0.9776 313/313 [==============================] - 0s 731us/step - loss: 0.2002 - sparse_categorical_accuracy: 0.9776 [0.20024622976779938, 0.9775999784469604] Overview of how to use the TensorFlow NumPy API to write Keras models. Introduction NumPy is a hugely successful Python linear algebra library. TensorFlow recently launched tf_numpy, a TensorFlow implementation of a large subset of the NumPy API. Thanks to tf_numpy, you can write Keras layers or models in the NumPy style! The TensorFlow NumPy API has full integration with the TensorFlow ecosystem. Features such as automatic differentiation, TensorBoard, Keras model callbacks, TPU distribution and model exporting are all supported. Let's run through a few examples. Setup TensorFlow NumPy requires TensorFlow 2.5 or later. import tensorflow as tf import tensorflow.experimental.numpy as tnp import keras import keras.layers as layers import numpy as np Optionally, you can call tnp.experimental_enable_numpy_behavior() to enable type promotion in TensorFlow. This allows TNP to more closely follow the NumPy standard. tnp.experimental_enable_numpy_behavior() To test our models we will use the Boston housing prices regression dataset. (x_train, y_train), (x_test, y_test) = tf.keras.datasets.boston_housing.load_data( path=\"boston_housing.npz\", test_split=0.2, seed=113 ) def evaluate_model(model: keras.Model): [loss, percent_error] = model.evaluate(x_test, y_test, verbose=0) print(\"Mean absolute percent error before training: \", percent_error) model.fit(x_train, y_train, epochs=200, verbose=0) [loss, percent_error] = model.evaluate(x_test, y_test, verbose=0) print(\"Mean absolute percent error after training:\", percent_error) Subclassing keras.Model with TNP The most flexible way to make use of the Keras API is to subclass the [keras.Model](/api/models/model#model-class) class. Subclassing the Model class gives you the ability to fully customize what occurs in the training loop. This makes subclassing Model a popular option for researchers. In this example, we will implement a Model subclass that performs regression over the boston housing dataset using the TNP API. Note that differentiation and gradient descent is handled automatically when using the TNP API alongside keras. First let's define a simple TNPForwardFeedRegressionNetwork class. class TNPForwardFeedRegressionNetwork(keras.Model): def __init__(self, blocks=None, **kwargs): super(TNPForwardFeedRegressionNetwork, self).__init__(**kwargs) if not isinstance(blocks, list): raise ValueError(f\"blocks must be a list, got blocks={blocks}\") self.blocks = blocks self.block_weights = None self.biases = None def build(self, input_shape): current_shape = input_shape[1] self.block_weights = [] self.biases = [] for i, block in enumerate(self.blocks): self.block_weights.append( self.add_weight( shape=(current_shape, block), trainable=True, name=f\"block-{i}\" ) ) self.biases.append( self.add_weight(shape=(block,), trainable=True, name=f\"bias-{i}\") ) current_shape = block self.linear_layer = self.add_weight( shape=(current_shape, 1), name=\"linear_projector\", trainable=True ) def call(self, inputs): activations = inputs for w, b in zip(self.block_weights, self.biases): activations = tnp.matmul(activations, w) + b # ReLu activation function activations = tnp.maximum(activations, 0.0) return tnp.matmul(activations, self.linear_layer) Just like with any other Keras model we can utilize any supported optimizer, loss, metrics or callbacks that we want. Let's see how the model performs! model = TNPForwardFeedRegressionNetwork(blocks=[3, 3]) model.compile( optimizer=\"adam\", loss=\"mean_squared_error\", metrics=[keras.metrics.MeanAbsolutePercentageError()], ) evaluate_model(model) Mean absolute percent error before training: 422.45343017578125 Mean absolute percent error after training: 97.24715423583984 Great! Our model seems to be effectively learning to solve the problem at hand. We can also write our own custom loss function using TNP. def tnp_mse(y_true, y_pred): return tnp.mean(tnp.square(y_true - y_pred), axis=0) keras.backend.clear_session() model = TNPForwardFeedRegressionNetwork(blocks=[3, 3]) model.compile( optimizer=\"adam\", loss=tnp_mse, metrics=[keras.metrics.MeanAbsolutePercentageError()], ) evaluate_model(model) Mean absolute percent error before training: 79.84039306640625 Mean absolute percent error after training: 28.658035278320312 Implementing a Keras Layer Based Model with TNP If desired, TNP can also be used in layer oriented Keras code structure. Let's implement the same model, but using a layered approach! def tnp_relu(x): return tnp.maximum(x, 0) class TNPDense(keras.layers.Layer): def __init__(self, units, activation=None): super().__init__() self.units = units self.activation = activation def build(self, input_shape): self.w = self.add_weight( name=\"weights\", shape=(input_shape[1], self.units), initializer=\"random_normal\", trainable=True, ) self.bias = self.add_weight( name=\"bias\", shape=(self.units,), initializer=\"random_normal\", trainable=True, ) def call(self, inputs): outputs = tnp.matmul(inputs, self.w) + self.bias if self.activation: return self.activation(outputs) return outputs def create_layered_tnp_model(): return keras.Sequential( [ TNPDense(3, activation=tnp_relu), TNPDense(3, activation=tnp_relu), TNPDense(1), ] ) model = create_layered_tnp_model() model.compile( optimizer=\"adam\", loss=\"mean_squared_error\", metrics=[keras.metrics.MeanAbsolutePercentageError()], ) model.build((None, 13,)) model.summary() evaluate_model(model) Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= tnp_dense (TNPDense) (None, 3) 42 _________________________________________________________________ tnp_dense_1 (TNPDense) (None, 3) 12 _________________________________________________________________ tnp_dense_2 (TNPDense) (None, 1) 4 ================================================================= Total params: 58 Trainable params: 58 Non-trainable params: 0 _________________________________________________________________ Mean absolute percent error before training: 101.17143249511719 Mean absolute percent error after training: 23.479856491088867 You can also seamlessly switch between TNP layers and native Keras layers! def create_mixed_model(): return keras.Sequential( [ TNPDense(3, activation=tnp_relu), # The model will have no issue using a normal Dense layer layers.Dense(3, activation=\"relu\"), # ... or switching back to tnp layers! TNPDense(1), ] ) model = create_mixed_model() model.compile( optimizer=\"adam\", loss=\"mean_squared_error\", metrics=[keras.metrics.MeanAbsolutePercentageError()], ) model.build((None, 13,)) model.summary() evaluate_model(model) Model: \"sequential_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= tnp_dense_3 (TNPDense) (None, 3) 42 _________________________________________________________________ dense (Dense) (None, 3) 12 _________________________________________________________________ tnp_dense_4 (TNPDense) (None, 1) 4 ================================================================= Total params: 58 Trainable params: 58 Non-trainable params: 0 _________________________________________________________________ Mean absolute percent error before training: 104.59967041015625 Mean absolute percent error after training: 27.712949752807617 The Keras API offers a wide variety of layers. The ability to use them alongside NumPy code can be a huge time saver in projects. Distribution Strategy TensorFlow NumPy and Keras integrate with TensorFlow Distribution Strategies. This makes it simple to perform distributed training across multiple GPUs, or even an entire TPU Pod. gpus = tf.config.list_logical_devices(\"GPU\") if gpus: strategy = tf.distribute.MirroredStrategy(gpus) else: # We can fallback to a no-op CPU strategy. strategy = tf.distribute.get_strategy() print(\"Running with strategy:\", str(strategy.__class__.__name__)) with strategy.scope(): model = create_layered_tnp_model() model.compile( optimizer=\"adam\", loss=\"mean_squared_error\", metrics=[keras.metrics.MeanAbsolutePercentageError()], ) model.build((None, 13,)) model.summary() evaluate_model(model) Running with strategy: _DefaultDistributionStrategy Model: \"sequential_2\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= tnp_dense_5 (TNPDense) (None, 3) 42 _________________________________________________________________ tnp_dense_6 (TNPDense) (None, 3) 12 _________________________________________________________________ tnp_dense_7 (TNPDense) (None, 1) 4 ================================================================= Total params: 58 Trainable params: 58 Non-trainable params: 0 _________________________________________________________________ Mean absolute percent error before training: 100.5331039428711 Mean absolute percent error after training: 20.71842384338379 TensorBoard Integration One of the many benefits of using the Keras API is the ability to monitor training through TensorBoard. Using the TensorFlow NumPy API alongside Keras allows you to easily leverage TensorBoard. keras.backend.clear_session() To load the TensorBoard from a Jupyter notebook, you can run the following magic: %load_ext tensorboard models = [ (TNPForwardFeedRegressionNetwork(blocks=[3, 3]), \"TNPForwardFeedRegressionNetwork\"), (create_layered_tnp_model(), \"layered_tnp_model\"), (create_mixed_model(), \"mixed_model\"), ] for model, model_name in models: model.compile( optimizer=\"adam\", loss=\"mean_squared_error\", metrics=[keras.metrics.MeanAbsolutePercentageError()], ) model.fit( x_train, y_train, epochs=200, verbose=0, callbacks=[keras.callbacks.TensorBoard(log_dir=f\"logs/{model_name}\")], ) To load the TensorBoard from a Jupyter notebook you can use the %tensorboard magic: %tensorboard --logdir logs The TensorBoard monitor metrics and examine the training curve. Tensorboard training graph The TensorBoard also allows you to explore the computation graph used in your models. Tensorboard graph exploration The ability to introspect into your models can be valuable during debugging. Conclusion Porting existing NumPy code to Keras models using the tensorflow_numpy API is easy! By integrating with Keras you gain the ability to use existing Keras callbacks, metrics and optimizers, easily distribute your training and use Tensorboard. Migrating a more complex model, such as a ResNet, to the TensorFlow NumPy API would be a great follow up learning exercise. Several open source NumPy ResNet implementations are available online. Implement Actor Critic Method in CartPole environment. Introduction This script shows an implementation of Actor Critic method on CartPole-V0 environment. Actor Critic Method As an agent takes actions and moves through an environment, it learns to map the observed state of the environment to two possible outputs: Recommended action: A probability value for each action in the action space. The part of the agent responsible for this output is called the actor. Estimated rewards in the future: Sum of all rewards it expects to receive in the future. The part of the agent responsible for this output is the critic. Agent and Critic learn to perform their tasks, such that the recommended actions from the actor maximize the rewards. CartPole-V0 A pole is attached to a cart placed on a frictionless track. The agent has to apply force to move the cart. It is rewarded for every time step the pole remains upright. The agent, therefore, must learn to keep the pole from falling over. References CartPole Actor Critic Method Setup import gym import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers # Configuration parameters for the whole setup seed = 42 gamma = 0.99 # Discount factor for past rewards max_steps_per_episode = 10000 env = gym.make(\"CartPole-v0\") # Create the environment env.seed(seed) eps = np.finfo(np.float32).eps.item() # Smallest number such that 1.0 + eps != 1.0 Implement Actor Critic network This network learns two functions: Actor: This takes as input the state of our environment and returns a probability value for each action in its action space. Critic: This takes as input the state of our environment and returns an estimate of total rewards in the future. In our implementation, they share the initial layer. num_inputs = 4 num_actions = 2 num_hidden = 128 inputs = layers.Input(shape=(num_inputs,)) common = layers.Dense(num_hidden, activation=\"relu\")(inputs) action = layers.Dense(num_actions, activation=\"softmax\")(common) critic = layers.Dense(1)(common) model = keras.Model(inputs=inputs, outputs=[action, critic]) Train optimizer = keras.optimizers.Adam(learning_rate=0.01) huber_loss = keras.losses.Huber() action_probs_history = [] critic_value_history = [] rewards_history = [] running_reward = 0 episode_count = 0 while True: # Run until solved state = env.reset() episode_reward = 0 with tf.GradientTape() as tape: for timestep in range(1, max_steps_per_episode): # env.render(); Adding this line would show the attempts # of the agent in a pop up window. state = tf.convert_to_tensor(state) state = tf.expand_dims(state, 0) # Predict action probabilities and estimated future rewards # from environment state action_probs, critic_value = model(state) critic_value_history.append(critic_value[0, 0]) # Sample action from action probability distribution action = np.random.choice(num_actions, p=np.squeeze(action_probs)) action_probs_history.append(tf.math.log(action_probs[0, action])) # Apply the sampled action in our environment state, reward, done, _ = env.step(action) rewards_history.append(reward) episode_reward += reward if done: break # Update running reward to check condition for solving running_reward = 0.05 * episode_reward + (1 - 0.05) * running_reward # Calculate expected value from rewards # - At each timestep what was the total reward received after that timestep # - Rewards in the past are discounted by multiplying them with gamma # - These are the labels for our critic returns = [] discounted_sum = 0 for r in rewards_history[::-1]: discounted_sum = r + gamma * discounted_sum returns.insert(0, discounted_sum) # Normalize returns = np.array(returns) returns = (returns - np.mean(returns)) / (np.std(returns) + eps) returns = returns.tolist() # Calculating loss values to update our network history = zip(action_probs_history, critic_value_history, returns) actor_losses = [] critic_losses = [] for log_prob, value, ret in history: # At this point in history, the critic estimated that we would get a # total reward = `value` in the future. We took an action with log probability # of `log_prob` and ended up recieving a total reward = `ret`. # The actor must be updated so that it predicts an action that leads to # high rewards (compared to critic's estimate) with high probability. diff = ret - value actor_losses.append(-log_prob * diff) # actor loss # The critic must be updated so that it predicts a better estimate of # the future rewards. critic_losses.append( huber_loss(tf.expand_dims(value, 0), tf.expand_dims(ret, 0)) ) # Backpropagation loss_value = sum(actor_losses) + sum(critic_losses) grads = tape.gradient(loss_value, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) # Clear the loss and reward history action_probs_history.clear() critic_value_history.clear() rewards_history.clear() # Log details episode_count += 1 if episode_count % 10 == 0: template = \"running reward: {:.2f} at episode {}\" print(template.format(running_reward, episode_count)) if running_reward > 195: # Condition to consider the task solved print(\"Solved at episode {}!\".format(episode_count)) break running reward: 8.82 at episode 10 running reward: 23.04 at episode 20 running reward: 28.41 at episode 30 running reward: 53.59 at episode 40 running reward: 53.71 at episode 50 running reward: 77.35 at episode 60 running reward: 74.76 at episode 70 running reward: 57.89 at episode 80 running reward: 46.59 at episode 90 running reward: 43.48 at episode 100 running reward: 63.77 at episode 110 running reward: 111.13 at episode 120 running reward: 142.77 at episode 130 running reward: 127.96 at episode 140 running reward: 113.92 at episode 150 running reward: 128.57 at episode 160 running reward: 139.95 at episode 170 running reward: 154.95 at episode 180 running reward: 171.45 at episode 190 running reward: 171.33 at episode 200 running reward: 177.74 at episode 210 running reward: 184.76 at episode 220 running reward: 190.88 at episode 230 running reward: 154.78 at episode 240 running reward: 114.38 at episode 250 running reward: 107.51 at episode 260 running reward: 128.99 at episode 270 running reward: 157.48 at episode 280 running reward: 174.54 at episode 290 running reward: 184.76 at episode 300 running reward: 190.87 at episode 310 running reward: 194.54 at episode 320 Solved at episode 322! Visualizations In early stages of training: Imgur In later stages of training: Imgur Implementing DDPG algorithm on the Inverted Pendulum Problem. Introduction Deep Deterministic Policy Gradient (DDPG) is a model-free off-policy algorithm for learning continous actions. It combines ideas from DPG (Deterministic Policy Gradient) and DQN (Deep Q-Network). It uses Experience Replay and slow-learning target networks from DQN, and it is based on DPG, which can operate over continuous action spaces. This tutorial closely follow this paper - Continuous control with deep reinforcement learning Problem We are trying to solve the classic Inverted Pendulum control problem. In this setting, we can take only two actions: swing left or swing right. What make this problem challenging for Q-Learning Algorithms is that actions are continuous instead of being discrete. That is, instead of using two discrete actions like -1 or +1, we have to select from infinite actions ranging from -2 to +2. Quick theory Just like the Actor-Critic method, we have two networks: Actor - It proposes an action given a state. Critic - It predicts if the action is good (positive value) or bad (negative value) given a state and an action. DDPG uses two more techniques not present in the original DQN: First, it uses two Target networks. Why? Because it add stability to training. In short, we are learning from estimated targets and Target networks are updated slowly, hence keeping our estimated targets stable. Conceptually, this is like saying, \"I have an idea of how to play this well, I'm going to try it out for a bit until I find something better\", as opposed to saying \"I'm going to re-learn how to play this entire game after every move\". See this StackOverflow answer. Second, it uses Experience Replay. We store list of tuples (state, action, reward, next_state), and instead of learning only from recent experience, we learn from sampling all of our experience accumulated so far. Now, let's see how is it implemented. import gym import tensorflow as tf from tensorflow.keras import layers import numpy as np import matplotlib.pyplot as plt We use OpenAIGym to create the environment. We will use the upper_bound parameter to scale our actions later. problem = \"Pendulum-v0\" env = gym.make(problem) num_states = env.observation_space.shape[0] print(\"Size of State Space -> {}\".format(num_states)) num_actions = env.action_space.shape[0] print(\"Size of Action Space -> {}\".format(num_actions)) upper_bound = env.action_space.high[0] lower_bound = env.action_space.low[0] print(\"Max Value of Action -> {}\".format(upper_bound)) print(\"Min Value of Action -> {}\".format(lower_bound)) Size of State Space -> 3 Size of Action Space -> 1 Max Value of Action -> 2.0 Min Value of Action -> -2.0 To implement better exploration by the Actor network, we use noisy perturbations, specifically an Ornstein-Uhlenbeck process for generating noise, as described in the paper. It samples noise from a correlated normal distribution. class OUActionNoise: def __init__(self, mean, std_deviation, theta=0.15, dt=1e-2, x_initial=None): self.theta = theta self.mean = mean self.std_dev = std_deviation self.dt = dt self.x_initial = x_initial self.reset() def __call__(self): # Formula taken from https://www.wikipedia.org/wiki/Ornstein-Uhlenbeck_process. x = ( self.x_prev + self.theta * (self.mean - self.x_prev) * self.dt + self.std_dev * np.sqrt(self.dt) * np.random.normal(size=self.mean.shape) ) # Store x into x_prev # Makes next noise dependent on current one self.x_prev = x return x def reset(self): if self.x_initial is not None: self.x_prev = self.x_initial else: self.x_prev = np.zeros_like(self.mean) The Buffer class implements Experience Replay. Algorithm Critic loss - Mean Squared Error of y - Q(s, a) where y is the expected return as seen by the Target network, and Q(s, a) is action value predicted by the Critic network. y is a moving target that the critic model tries to achieve; we make this target stable by updating the Target model slowly. Actor loss - This is computed using the mean of the value given by the Critic network for the actions taken by the Actor network. We seek to maximize this quantity. Hence we update the Actor network so that it produces actions that get the maximum predicted value as seen by the Critic, for a given state. class Buffer: def __init__(self, buffer_capacity=100000, batch_size=64): # Number of \"experiences\" to store at max self.buffer_capacity = buffer_capacity # Num of tuples to train on. self.batch_size = batch_size # Its tells us num of times record() was called. self.buffer_counter = 0 # Instead of list of tuples as the exp.replay concept go # We use different np.arrays for each tuple element self.state_buffer = np.zeros((self.buffer_capacity, num_states)) self.action_buffer = np.zeros((self.buffer_capacity, num_actions)) self.reward_buffer = np.zeros((self.buffer_capacity, 1)) self.next_state_buffer = np.zeros((self.buffer_capacity, num_states)) # Takes (s,a,r,s') obervation tuple as input def record(self, obs_tuple): # Set index to zero if buffer_capacity is exceeded, # replacing old records index = self.buffer_counter % self.buffer_capacity self.state_buffer[index] = obs_tuple[0] self.action_buffer[index] = obs_tuple[1] self.reward_buffer[index] = obs_tuple[2] self.next_state_buffer[index] = obs_tuple[3] self.buffer_counter += 1 # Eager execution is turned on by default in TensorFlow 2. Decorating with tf.function allows # TensorFlow to build a static graph out of the logic and computations in our function. # This provides a large speed up for blocks of code that contain many small TensorFlow operations such as this one. @tf.function def update( self, state_batch, action_batch, reward_batch, next_state_batch, ): # Training and updating Actor & Critic networks. # See Pseudo Code. with tf.GradientTape() as tape: target_actions = target_actor(next_state_batch, training=True) y = reward_batch + gamma * target_critic( [next_state_batch, target_actions], training=True ) critic_value = critic_model([state_batch, action_batch], training=True) critic_loss = tf.math.reduce_mean(tf.math.square(y - critic_value)) critic_grad = tape.gradient(critic_loss, critic_model.trainable_variables) critic_optimizer.apply_gradients( zip(critic_grad, critic_model.trainable_variables) ) with tf.GradientTape() as tape: actions = actor_model(state_batch, training=True) critic_value = critic_model([state_batch, actions], training=True) # Used `-value` as we want to maximize the value given # by the critic for our actions actor_loss = -tf.math.reduce_mean(critic_value) actor_grad = tape.gradient(actor_loss, actor_model.trainable_variables) actor_optimizer.apply_gradients( zip(actor_grad, actor_model.trainable_variables) ) # We compute the loss and update parameters def learn(self): # Get sampling range record_range = min(self.buffer_counter, self.buffer_capacity) # Randomly sample indices batch_indices = np.random.choice(record_range, self.batch_size) # Convert to tensors state_batch = tf.convert_to_tensor(self.state_buffer[batch_indices]) action_batch = tf.convert_to_tensor(self.action_buffer[batch_indices]) reward_batch = tf.convert_to_tensor(self.reward_buffer[batch_indices]) reward_batch = tf.cast(reward_batch, dtype=tf.float32) next_state_batch = tf.convert_to_tensor(self.next_state_buffer[batch_indices]) self.update(state_batch, action_batch, reward_batch, next_state_batch) # This update target parameters slowly # Based on rate `tau`, which is much less than one. @tf.function def update_target(target_weights, weights, tau): for (a, b) in zip(target_weights, weights): a.assign(b * tau + a * (1 - tau)) Here we define the Actor and Critic networks. These are basic Dense models with ReLU activation. Note: We need the initialization for last layer of the Actor to be between -0.003 and 0.003 as this prevents us from getting 1 or -1 output values in the initial stages, which would squash our gradients to zero, as we use the tanh activation. def get_actor(): # Initialize weights between -3e-3 and 3-e3 last_init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003) inputs = layers.Input(shape=(num_states,)) out = layers.Dense(256, activation=\"relu\")(inputs) out = layers.Dense(256, activation=\"relu\")(out) outputs = layers.Dense(1, activation=\"tanh\", kernel_initializer=last_init)(out) # Our upper bound is 2.0 for Pendulum. outputs = outputs * upper_bound model = tf.keras.Model(inputs, outputs) return model def get_critic(): # State as input state_input = layers.Input(shape=(num_states)) state_out = layers.Dense(16, activation=\"relu\")(state_input) state_out = layers.Dense(32, activation=\"relu\")(state_out) # Action as input action_input = layers.Input(shape=(num_actions)) action_out = layers.Dense(32, activation=\"relu\")(action_input) # Both are passed through seperate layer before concatenating concat = layers.Concatenate()([state_out, action_out]) out = layers.Dense(256, activation=\"relu\")(concat) out = layers.Dense(256, activation=\"relu\")(out) outputs = layers.Dense(1)(out) # Outputs single value for give state-action model = tf.keras.Model([state_input, action_input], outputs) return model policy() returns an action sampled from our Actor network plus some noise for exploration. def policy(state, noise_object): sampled_actions = tf.squeeze(actor_model(state)) noise = noise_object() # Adding noise to action sampled_actions = sampled_actions.numpy() + noise # We make sure action is within bounds legal_action = np.clip(sampled_actions, lower_bound, upper_bound) return [np.squeeze(legal_action)] Training hyperparameters std_dev = 0.2 ou_noise = OUActionNoise(mean=np.zeros(1), std_deviation=float(std_dev) * np.ones(1)) actor_model = get_actor() critic_model = get_critic() target_actor = get_actor() target_critic = get_critic() # Making the weights equal initially target_actor.set_weights(actor_model.get_weights()) target_critic.set_weights(critic_model.get_weights()) # Learning rate for actor-critic models critic_lr = 0.002 actor_lr = 0.001 critic_optimizer = tf.keras.optimizers.Adam(critic_lr) actor_optimizer = tf.keras.optimizers.Adam(actor_lr) total_episodes = 100 # Discount factor for future rewards gamma = 0.99 # Used to update target networks tau = 0.005 buffer = Buffer(50000, 64) Now we implement our main training loop, and iterate over episodes. We sample actions using policy() and train with learn() at each time step, along with updating the Target networks at a rate tau. # To store reward history of each episode ep_reward_list = [] # To store average reward history of last few episodes avg_reward_list = [] # Takes about 4 min to train for ep in range(total_episodes): prev_state = env.reset() episodic_reward = 0 while True: # Uncomment this to see the Actor in action # But not in a python notebook. # env.render() tf_prev_state = tf.expand_dims(tf.convert_to_tensor(prev_state), 0) action = policy(tf_prev_state, ou_noise) # Recieve state and reward from environment. state, reward, done, info = env.step(action) buffer.record((prev_state, action, reward, state)) episodic_reward += reward buffer.learn() update_target(target_actor.variables, actor_model.variables, tau) update_target(target_critic.variables, critic_model.variables, tau) # End this episode when `done` is True if done: break prev_state = state ep_reward_list.append(episodic_reward) # Mean of last 40 episodes avg_reward = np.mean(ep_reward_list[-40:]) print(\"Episode * {} * Avg Reward is ==> {}\".format(ep, avg_reward)) avg_reward_list.append(avg_reward) # Plotting graph # Episodes versus Avg. Rewards plt.plot(avg_reward_list) plt.xlabel(\"Episode\") plt.ylabel(\"Avg. Epsiodic Reward\") plt.show() Episode * 0 * Avg Reward is ==> -1269.3278950595395 Episode * 1 * Avg Reward is ==> -1528.3008939716287 Episode * 2 * Avg Reward is ==> -1511.1737868279706 Episode * 3 * Avg Reward is ==> -1512.8568141261057 Episode * 4 * Avg Reward is ==> -1386.054573343386 Episode * 5 * Avg Reward is ==> -1411.4818856846339 Episode * 6 * Avg Reward is ==> -1431.6790621961388 Episode * 7 * Avg Reward is ==> -1427.9515009474867 Episode * 8 * Avg Reward is ==> -1392.9313930075857 Episode * 9 * Avg Reward is ==> -1346.6839043846012 Episode * 10 * Avg Reward is ==> -1325.5818224096574 Episode * 11 * Avg Reward is ==> -1271.778361283553 Episode * 12 * Avg Reward is ==> -1194.0784354001732 Episode * 13 * Avg Reward is ==> -1137.1096928093427 Episode * 14 * Avg Reward is ==> -1087.2426176918214 Episode * 15 * Avg Reward is ==> -1043.5265287176114 Episode * 16 * Avg Reward is ==> -990.0857409180443 Episode * 17 * Avg Reward is ==> -949.0661362879348 Episode * 18 * Avg Reward is ==> -906.1744575963231 Episode * 19 * Avg Reward is ==> -914.0098344966382 Episode * 20 * Avg Reward is ==> -886.8905055354011 Episode * 21 * Avg Reward is ==> -859.3416389004793 Episode * 22 * Avg Reward is ==> -827.5405203616622 Episode * 23 * Avg Reward is ==> -798.3875178404127 Episode * 24 * Avg Reward is ==> -771.289491103158 Episode * 25 * Avg Reward is ==> -741.6622445749622 Episode * 26 * Avg Reward is ==> -727.7080867854874 Episode * 27 * Avg Reward is ==> -710.485046117201 Episode * 28 * Avg Reward is ==> -690.3850022530833 Episode * 29 * Avg Reward is ==> -671.3205042911178 Episode * 30 * Avg Reward is ==> -653.4475135842247 Episode * 31 * Avg Reward is ==> -637.0057392119055 Episode * 32 * Avg Reward is ==> -629.2474166794424 Episode * 33 * Avg Reward is ==> -614.4655398230501 Episode * 34 * Avg Reward is ==> -603.3854873345723 Episode * 35 * Avg Reward is ==> -589.86534490467 Episode * 36 * Avg Reward is ==> -577.1806480684269 Episode * 37 * Avg Reward is ==> -565.1365286280546 Episode * 38 * Avg Reward is ==> -550.6647028563134 Episode * 39 * Avg Reward is ==> -540.0095147571197 Episode * 40 * Avg Reward is ==> -517.3861294233157 Episode * 41 * Avg Reward is ==> -478.705352005952 Episode * 42 * Avg Reward is ==> -444.8350788756713 Episode * 43 * Avg Reward is ==> -409.85293165991334 Episode * 44 * Avg Reward is ==> -390.83984710631546 Episode * 45 * Avg Reward is ==> -360.88156865913675 Episode * 46 * Avg Reward is ==> -325.26685315168595 Episode * 47 * Avg Reward is ==> -290.2315644399411 Episode * 48 * Avg Reward is ==> -268.0351126010609 Episode * 49 * Avg Reward is ==> -247.8952699063706 Episode * 50 * Avg Reward is ==> -222.99123461788048 Episode * 51 * Avg Reward is ==> -209.0830401020491 Episode * 52 * Avg Reward is ==> -205.65143423678765 Episode * 53 * Avg Reward is ==> -201.8910585767988 Episode * 54 * Avg Reward is ==> -192.18560466037357 Episode * 55 * Avg Reward is ==> -189.43475813660137 Episode * 56 * Avg Reward is ==> -191.92700535454787 Episode * 57 * Avg Reward is ==> -188.5196218645745 Episode * 58 * Avg Reward is ==> -188.17872234729674 Episode * 59 * Avg Reward is ==> -167.33043921566485 Episode * 60 * Avg Reward is ==> -165.01361185173954 Episode * 61 * Avg Reward is ==> -164.5316658073024 Episode * 62 * Avg Reward is ==> -164.4025677076815 Episode * 63 * Avg Reward is ==> -167.27842005634784 Episode * 64 * Avg Reward is ==> -167.12049955654845 Episode * 65 * Avg Reward is ==> -170.02761731078783 Episode * 66 * Avg Reward is ==> -167.56039601863873 Episode * 67 * Avg Reward is ==> -164.60482495249738 Episode * 68 * Avg Reward is ==> -167.45278232469394 Episode * 69 * Avg Reward is ==> -167.42407364484592 Episode * 70 * Avg Reward is ==> -167.57794933965346 Episode * 71 * Avg Reward is ==> -170.6408611483338 Episode * 72 * Avg Reward is ==> -163.96954092530822 Episode * 73 * Avg Reward is ==> -160.82007525469245 Episode * 74 * Avg Reward is ==> -158.38239222565778 Episode * 75 * Avg Reward is ==> -158.3554729720654 Episode * 76 * Avg Reward is ==> -158.51036948298994 Episode * 77 * Avg Reward is ==> -158.68906473090686 Episode * 78 * Avg Reward is ==> -164.60260866654318 Episode * 79 * Avg Reward is ==> -161.5493472156026 Episode * 80 * Avg Reward is ==> -152.48077012719403 Episode * 81 * Avg Reward is ==> -149.52532010375975 Episode * 82 * Avg Reward is ==> -149.61942419730423 Episode * 83 * Avg Reward is ==> -149.82443455067468 Episode * 84 * Avg Reward is ==> -149.80009937226978 Episode * 85 * Avg Reward is ==> -144.51659331262107 Episode * 86 * Avg Reward is ==> -150.7545561142967 Episode * 87 * Avg Reward is ==> -153.84772667131307 Episode * 88 * Avg Reward is ==> -151.35200443047225 Episode * 89 * Avg Reward is ==> -148.30392250041828 Episode * 90 * Avg Reward is ==> -151.33886235855053 Episode * 91 * Avg Reward is ==> -151.153096135589 Episode * 92 * Avg Reward is ==> -151.19626034791332 Episode * 93 * Avg Reward is ==> -151.15870791946685 Episode * 94 * Avg Reward is ==> -154.2673372216281 Episode * 95 * Avg Reward is ==> -150.40737651480134 Episode * 96 * Avg Reward is ==> -147.7969116731913 Episode * 97 * Avg Reward is ==> -147.88640802454557 Episode * 98 * Avg Reward is ==> -144.88997165191319 Episode * 99 * Avg Reward is ==> -142.22158276699662 png If training proceeds correctly, the average episodic reward will increase with time. Feel free to try different learning rates, tau values, and architectures for the Actor and Critic networks. The Inverted Pendulum problem has low complexity, but DDPG work great on many other problems. Another great environment to try this on is LunarLandingContinuous-v2, but it will take more episodes to obtain good results. # Save the weights actor_model.save_weights(\"pendulum_actor.h5\") critic_model.save_weights(\"pendulum_critic.h5\") target_actor.save_weights(\"pendulum_target_actor.h5\") target_critic.save_weights(\"pendulum_target_critic.h5\") Before Training: before_img After 100 episodes: after_img Play Atari Breakout with a Deep Q-Network. Introduction This script shows an implementation of Deep Q-Learning on the BreakoutNoFrameskip-v4 environment. Deep Q-Learning As an agent takes actions and moves through an environment, it learns to map the observed state of the environment to an action. An agent will choose an action in a given state based on a \"Q-value\", which is a weighted reward based on the expected highest long-term reward. A Q-Learning Agent learns to perform its task such that the recommended action maximizes the potential future rewards. This method is considered an \"Off-Policy\" method, meaning its Q values are updated assuming that the best action was chosen, even if the best action was not chosen. Atari Breakout In this environment, a board moves along the bottom of the screen returning a ball that will destroy blocks at the top of the screen. The aim of the game is to remove all blocks and breakout of the level. The agent must learn to control the board by moving left and right, returning the ball and removing all the blocks without the ball passing the board. Note The Deepmind paper trained for \"a total of 50 million frames (that is, around 38 days of game experience in total)\". However this script will give good results at around 10 million frames which are processed in less than 24 hours on a modern machine. References Q-Learning Deep Q-Learning Setup from baselines.common.atari_wrappers import make_atari, wrap_deepmind import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers # Configuration paramaters for the whole setup seed = 42 gamma = 0.99 # Discount factor for past rewards epsilon = 1.0 # Epsilon greedy parameter epsilon_min = 0.1 # Minimum epsilon greedy parameter epsilon_max = 1.0 # Maximum epsilon greedy parameter epsilon_interval = ( epsilon_max - epsilon_min ) # Rate at which to reduce chance of random action being taken batch_size = 32 # Size of batch taken from replay buffer max_steps_per_episode = 10000 # Use the Baseline Atari environment because of Deepmind helper functions env = make_atari(\"BreakoutNoFrameskip-v4\") # Warp the frames, grey scale, stake four frame and scale to smaller ratio env = wrap_deepmind(env, frame_stack=True, scale=True) env.seed(seed) Implement the Deep Q-Network This network learns an approximation of the Q-table, which is a mapping between the states and actions that an agent will take. For every state we'll have four actions, that can be taken. The environment provides the state, and the action is chosen by selecting the larger of the four Q-values predicted in the output layer. num_actions = 4 def create_q_model(): # Network defined by the Deepmind paper inputs = layers.Input(shape=(84, 84, 4,)) # Convolutions on the frames on the screen layer1 = layers.Conv2D(32, 8, strides=4, activation=\"relu\")(inputs) layer2 = layers.Conv2D(64, 4, strides=2, activation=\"relu\")(layer1) layer3 = layers.Conv2D(64, 3, strides=1, activation=\"relu\")(layer2) layer4 = layers.Flatten()(layer3) layer5 = layers.Dense(512, activation=\"relu\")(layer4) action = layers.Dense(num_actions, activation=\"linear\")(layer5) return keras.Model(inputs=inputs, outputs=action) # The first model makes the predictions for Q-values which are used to # make a action. model = create_q_model() # Build a target model for the prediction of future rewards. # The weights of a target model get updated every 10000 steps thus when the # loss between the Q-values is calculated the target Q-value is stable. model_target = create_q_model() Train # In the Deepmind paper they use RMSProp however then Adam optimizer # improves training time optimizer = keras.optimizers.Adam(learning_rate=0.00025, clipnorm=1.0) # Experience replay buffers action_history = [] state_history = [] state_next_history = [] rewards_history = [] done_history = [] episode_reward_history = [] running_reward = 0 episode_count = 0 frame_count = 0 # Number of frames to take random action and observe output epsilon_random_frames = 50000 # Number of frames for exploration epsilon_greedy_frames = 1000000.0 # Maximum replay length # Note: The Deepmind paper suggests 1000000 however this causes memory issues max_memory_length = 100000 # Train the model after 4 actions update_after_actions = 4 # How often to update the target network update_target_network = 10000 # Using huber loss for stability loss_function = keras.losses.Huber() while True: # Run until solved state = np.array(env.reset()) episode_reward = 0 for timestep in range(1, max_steps_per_episode): # env.render(); Adding this line would show the attempts # of the agent in a pop up window. frame_count += 1 # Use epsilon-greedy for exploration if frame_count < epsilon_random_frames or epsilon > np.random.rand(1)[0]: # Take random action action = np.random.choice(num_actions) else: # Predict action Q-values # From environment state state_tensor = tf.convert_to_tensor(state) state_tensor = tf.expand_dims(state_tensor, 0) action_probs = model(state_tensor, training=False) # Take best action action = tf.argmax(action_probs[0]).numpy() # Decay probability of taking random action epsilon -= epsilon_interval / epsilon_greedy_frames epsilon = max(epsilon, epsilon_min) # Apply the sampled action in our environment state_next, reward, done, _ = env.step(action) state_next = np.array(state_next) episode_reward += reward # Save actions and states in replay buffer action_history.append(action) state_history.append(state) state_next_history.append(state_next) done_history.append(done) rewards_history.append(reward) state = state_next # Update every fourth frame and once batch size is over 32 if frame_count % update_after_actions == 0 and len(done_history) > batch_size: # Get indices of samples for replay buffers indices = np.random.choice(range(len(done_history)), size=batch_size) # Using list comprehension to sample from replay buffer state_sample = np.array([state_history[i] for i in indices]) state_next_sample = np.array([state_next_history[i] for i in indices]) rewards_sample = [rewards_history[i] for i in indices] action_sample = [action_history[i] for i in indices] done_sample = tf.convert_to_tensor( [float(done_history[i]) for i in indices] ) # Build the updated Q-values for the sampled future states # Use the target model for stability future_rewards = model_target.predict(state_next_sample) # Q value = reward + discount factor * expected future reward updated_q_values = rewards_sample + gamma * tf.reduce_max( future_rewards, axis=1 ) # If final frame set the last value to -1 updated_q_values = updated_q_values * (1 - done_sample) - done_sample # Create a mask so we only calculate loss on the updated Q-values masks = tf.one_hot(action_sample, num_actions) with tf.GradientTape() as tape: # Train the model on the states and updated Q-values q_values = model(state_sample) # Apply the masks to the Q-values to get the Q-value for action taken q_action = tf.reduce_sum(tf.multiply(q_values, masks), axis=1) # Calculate loss between new Q-value and old Q-value loss = loss_function(updated_q_values, q_action) # Backpropagation grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) if frame_count % update_target_network == 0: # update the the target network with new weights model_target.set_weights(model.get_weights()) # Log details template = \"running reward: {:.2f} at episode {}, frame count {}\" print(template.format(running_reward, episode_count, frame_count)) # Limit the state and reward history if len(rewards_history) > max_memory_length: del rewards_history[:1] del state_history[:1] del state_next_history[:1] del action_history[:1] del done_history[:1] if done: break # Update running reward to check condition for solving episode_reward_history.append(episode_reward) if len(episode_reward_history) > 100: del episode_reward_history[:1] running_reward = np.mean(episode_reward_history) episode_count += 1 if running_reward > 40: # Condition to consider the task solved print(\"Solved at episode {}!\".format(episode_count)) break Visualizations Before any training: Imgur In early stages of training: Imgur In later stages of training: Imgur Implementation of a Proximal Policy Optimization agent for the CartPole-v0 environment. Introduction This code example solves the CartPole-v0 environment using a Proximal Policy Optimization (PPO) agent. CartPole-v0 A pole is attached by an un-actuated joint to a cart, which moves along a frictionless track. The system is controlled by applying a force of +1 or -1 to the cart. The pendulum starts upright, and the goal is to prevent it from falling over. A reward of +1 is provided for every timestep that the pole remains upright. The episode ends when the pole is more than 15 degrees from vertical, or the cart moves more than 2.4 units from the center. After 200 steps the episode ends. Thus, the highest return we can get is equal to 200. CartPole-v0 Proximal Policy Optimization PPO is a policy gradient method and can be used for environments with either discrete or continuous action spaces. It trains a stochastic policy in an on-policy way. Also, it utilizes the actor critic method. The actor maps the observation to an action and the critic gives an expectation of the rewards of the agent for the observation given. Firstly, it collects a set of trajectories for each epoch by sampling from the latest version of the stochastic policy. Then, the rewards-to-go and the advantage estimates are computed in order to update the policy and fit the value function. The policy is updated via a stochastic gradient ascent optimizer, while the value function is fitted via some gradient descent algorithm. This procedure is applied for many epochs until the environment is solved. Algorithm PPO Original Paper OpenAI Spinning Up docs - PPO Note This code example uses Keras and Tensorflow v2. It is based on the PPO Original Paper, the OpenAI's Spinning Up docs for PPO, and the OpenAI's Spinning Up implementation of PPO using Tensorflow v1. OpenAI Spinning Up Github - PPO Libraries For this example the following libraries are used: numpy for n-dimensional arrays tensorflow and keras for building the deep RL PPO agent gym for getting everything we need about the environment scipy.signal for calculating the discounted cumulative sums of vectors import numpy as np import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import gym import scipy.signal import time Functions and class def discounted_cumulative_sums(x, discount): # Discounted cumulative sums of vectors for computing rewards-to-go and advantage estimates return scipy.signal.lfilter([1], [1, float(-discount)], x[::-1], axis=0)[::-1] class Buffer: # Buffer for storing trajectories def __init__(self, observation_dimensions, size, gamma=0.99, lam=0.95): # Buffer initialization self.observation_buffer = np.zeros( (size, observation_dimensions), dtype=np.float32 ) self.action_buffer = np.zeros(size, dtype=np.int32) self.advantage_buffer = np.zeros(size, dtype=np.float32) self.reward_buffer = np.zeros(size, dtype=np.float32) self.return_buffer = np.zeros(size, dtype=np.float32) self.value_buffer = np.zeros(size, dtype=np.float32) self.logprobability_buffer = np.zeros(size, dtype=np.float32) self.gamma, self.lam = gamma, lam self.pointer, self.trajectory_start_index = 0, 0 def store(self, observation, action, reward, value, logprobability): # Append one step of agent-environment interaction self.observation_buffer[self.pointer] = observation self.action_buffer[self.pointer] = action self.reward_buffer[self.pointer] = reward self.value_buffer[self.pointer] = value self.logprobability_buffer[self.pointer] = logprobability self.pointer += 1 def finish_trajectory(self, last_value=0): # Finish the trajectory by computing advantage estimates and rewards-to-go path_slice = slice(self.trajectory_start_index, self.pointer) rewards = np.append(self.reward_buffer[path_slice], last_value) values = np.append(self.value_buffer[path_slice], last_value) deltas = rewards[:-1] + self.gamma * values[1:] - values[:-1] self.advantage_buffer[path_slice] = discounted_cumulative_sums( deltas, self.gamma * self.lam ) self.return_buffer[path_slice] = discounted_cumulative_sums( rewards, self.gamma )[:-1] self.trajectory_start_index = self.pointer def get(self): # Get all data of the buffer and normalize the advantages self.pointer, self.trajectory_start_index = 0, 0 advantage_mean, advantage_std = ( np.mean(self.advantage_buffer), np.std(self.advantage_buffer), ) self.advantage_buffer = (self.advantage_buffer - advantage_mean) / advantage_std return ( self.observation_buffer, self.action_buffer, self.advantage_buffer, self.return_buffer, self.logprobability_buffer, ) def mlp(x, sizes, activation=tf.tanh, output_activation=None): # Build a feedforward neural network for size in sizes[:-1]: x = layers.Dense(units=size, activation=activation)(x) return layers.Dense(units=sizes[-1], activation=output_activation)(x) def logprobabilities(logits, a): # Compute the log-probabilities of taking actions a by using the logits (i.e. the output of the actor) logprobabilities_all = tf.nn.log_softmax(logits) logprobability = tf.reduce_sum( tf.one_hot(a, num_actions) * logprobabilities_all, axis=1 ) return logprobability # Sample action from actor @tf.function def sample_action(observation): logits = actor(observation) action = tf.squeeze(tf.random.categorical(logits, 1), axis=1) return logits, action # Train the policy by maxizing the PPO-Clip objective @tf.function def train_policy( observation_buffer, action_buffer, logprobability_buffer, advantage_buffer ): with tf.GradientTape() as tape: # Record operations for automatic differentiation. ratio = tf.exp( logprobabilities(actor(observation_buffer), action_buffer) - logprobability_buffer ) min_advantage = tf.where( advantage_buffer > 0, (1 + clip_ratio) * advantage_buffer, (1 - clip_ratio) * advantage_buffer, ) policy_loss = -tf.reduce_mean( tf.minimum(ratio * advantage_buffer, min_advantage) ) policy_grads = tape.gradient(policy_loss, actor.trainable_variables) policy_optimizer.apply_gradients(zip(policy_grads, actor.trainable_variables)) kl = tf.reduce_mean( logprobability_buffer - logprobabilities(actor(observation_buffer), action_buffer) ) kl = tf.reduce_sum(kl) return kl # Train the value function by regression on mean-squared error @tf.function def train_value_function(observation_buffer, return_buffer): with tf.GradientTape() as tape: # Record operations for automatic differentiation. value_loss = tf.reduce_mean((return_buffer - critic(observation_buffer)) ** 2) value_grads = tape.gradient(value_loss, critic.trainable_variables) value_optimizer.apply_gradients(zip(value_grads, critic.trainable_variables)) Hyperparameters # Hyperparameters of the PPO algorithm steps_per_epoch = 4000 epochs = 30 gamma = 0.99 clip_ratio = 0.2 policy_learning_rate = 3e-4 value_function_learning_rate = 1e-3 train_policy_iterations = 80 train_value_iterations = 80 lam = 0.97 target_kl = 0.01 hidden_sizes = (64, 64) # True if you want to render the environment render = False Initializations # Initialize the environment and get the dimensionality of the # observation space and the number of possible actions env = gym.make(\"CartPole-v0\") observation_dimensions = env.observation_space.shape[0] num_actions = env.action_space.n # Initialize the buffer buffer = Buffer(observation_dimensions, steps_per_epoch) # Initialize the actor and the critic as keras models observation_input = keras.Input(shape=(observation_dimensions,), dtype=tf.float32) logits = mlp(observation_input, list(hidden_sizes) + [num_actions], tf.tanh, None) actor = keras.Model(inputs=observation_input, outputs=logits) value = tf.squeeze( mlp(observation_input, list(hidden_sizes) + [1], tf.tanh, None), axis=1 ) critic = keras.Model(inputs=observation_input, outputs=value) # Initialize the policy and the value function optimizers policy_optimizer = keras.optimizers.Adam(learning_rate=policy_learning_rate) value_optimizer = keras.optimizers.Adam(learning_rate=value_function_learning_rate) # Initialize the observation, episode return and episode length observation, episode_return, episode_length = env.reset(), 0, 0 Train # Iterate over the number of epochs for epoch in range(epochs): # Initialize the sum of the returns, lengths and number of episodes for each epoch sum_return = 0 sum_length = 0 num_episodes = 0 # Iterate over the steps of each epoch for t in range(steps_per_epoch): if render: env.render() # Get the logits, action, and take one step in the environment observation = observation.reshape(1, -1) logits, action = sample_action(observation) observation_new, reward, done, _ = env.step(action[0].numpy()) episode_return += reward episode_length += 1 # Get the value and log-probability of the action value_t = critic(observation) logprobability_t = logprobabilities(logits, action) # Store obs, act, rew, v_t, logp_pi_t buffer.store(observation, action, reward, value_t, logprobability_t) # Update the observation observation = observation_new # Finish trajectory if reached to a terminal state terminal = done if terminal or (t == steps_per_epoch - 1): last_value = 0 if done else critic(observation.reshape(1, -1)) buffer.finish_trajectory(last_value) sum_return += episode_return sum_length += episode_length num_episodes += 1 observation, episode_return, episode_length = env.reset(), 0, 0 # Get values from the buffer ( observation_buffer, action_buffer, advantage_buffer, return_buffer, logprobability_buffer, ) = buffer.get() # Update the policy and implement early stopping using KL divergence for _ in range(train_policy_iterations): kl = train_policy( observation_buffer, action_buffer, logprobability_buffer, advantage_buffer ) if kl > 1.5 * target_kl: # Early Stopping break # Update the value function for _ in range(train_value_iterations): train_value_function(observation_buffer, return_buffer) # Print mean return and length for each epoch print( f\" Epoch: {epoch + 1}. Mean Return: {sum_return / num_episodes}. Mean Length: {sum_length / num_episodes}\" ) Epoch: 1. Mean Return: 18.01801801801802. Mean Length: 18.01801801801802 Epoch: 2. Mean Return: 21.978021978021978. Mean Length: 21.978021978021978 Epoch: 3. Mean Return: 27.397260273972602. Mean Length: 27.397260273972602 Epoch: 4. Mean Return: 36.69724770642202. Mean Length: 36.69724770642202 Epoch: 5. Mean Return: 48.19277108433735. Mean Length: 48.19277108433735 Epoch: 6. Mean Return: 66.66666666666667. Mean Length: 66.66666666666667 Epoch: 7. Mean Return: 133.33333333333334. Mean Length: 133.33333333333334 Epoch: 8. Mean Return: 166.66666666666666. Mean Length: 166.66666666666666 Epoch: 9. Mean Return: 181.8181818181818. Mean Length: 181.8181818181818 Epoch: 10. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 11. Mean Return: 200.0. Mean Length: 200.0 Epoch: 12. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 13. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 14. Mean Return: 181.8181818181818. Mean Length: 181.8181818181818 Epoch: 15. Mean Return: 181.8181818181818. Mean Length: 181.8181818181818 Epoch: 16. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 17. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 18. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 19. Mean Return: 200.0. Mean Length: 200.0 Epoch: 20. Mean Return: 200.0. Mean Length: 200.0 Epoch: 21. Mean Return: 200.0. Mean Length: 200.0 Epoch: 22. Mean Return: 200.0. Mean Length: 200.0 Epoch: 23. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 24. Mean Return: 190.47619047619048. Mean Length: 190.47619047619048 Epoch: 25. Mean Return: 200.0. Mean Length: 200.0 Epoch: 26. Mean Return: 200.0. Mean Length: 200.0 Epoch: 27. Mean Return: 200.0. Mean Length: 200.0 Epoch: 28. Mean Return: 200.0. Mean Length: 200.0 Epoch: 29. Mean Return: 200.0. Mean Length: 200.0 Epoch: 30. Mean Return: 200.0. Mean Length: 200.0 Visualizations Before training: Imgur After 8 epochs of training: Imgur After 20 epochs of training: Imgur Rating rate prediction using the Behavior Sequence Transformer (BST) model on the Movielens. Introduction This example demonstrates the Behavior Sequence Transformer (BST) model, by Qiwei Chen et al., using the Movielens dataset. The BST model leverages the sequential behaviour of the users in watching and rating movies, as well as user profile and movie features, to predict the rating of the user to a target movie. More precisely, the BST model aims to predict the rating of a target movie by accepting the following inputs: A fixed-length sequence of movie_ids watched by a user. A fixed-length sequence of the ratings for the movies watched by a user. A set of user features, including user_id, sex, occupation, and age_group. A set of genres for each movie in the input sequence and the target movie. A target_movie_id for which to predict the rating. This example modifies the original BST model in the following ways: We incorporate the movie features (genres) into the processing of the embedding of each movie of the input sequence and the target movie, rather than treating them as \"other features\" outside the transformer layer. We utilize the ratings of movies in the input sequence, along with the their positions in the sequence, to update them before feeding them into the self-attention layer. Note that this example should be run with TensorFlow 2.4 or higher. The dataset We use the 1M version of the Movielens dataset. The dataset includes around 1 million ratings from 6000 users on 4000 movies, along with some user features, movie genres. In addition, the timestamp of each user-movie rating is provided, which allows creating sequences of movie ratings for each user, as expected by the BST model. Setup import os import math from zipfile import ZipFile from urllib.request import urlretrieve import numpy as np import pandas as pd import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.layers import StringLookup Prepare the data Download and prepare the DataFrames First, let's download the movielens data. The downloaded folder will contain three data files: users.dat, movies.dat, and ratings.dat. urlretrieve(\"http://files.grouplens.org/datasets/movielens/ml-1m.zip\", \"movielens.zip\") ZipFile(\"movielens.zip\", \"r\").extractall() Then, we load the data into pandas DataFrames with their proper column names. users = pd.read_csv( \"ml-1m/users.dat\", sep=\"::\", names=[\"user_id\", \"sex\", \"age_group\", \"occupation\", \"zip_code\"], ) ratings = pd.read_csv( \"ml-1m/ratings.dat\", sep=\"::\", names=[\"user_id\", \"movie_id\", \"rating\", \"unix_timestamp\"], ) movies = pd.read_csv( \"ml-1m/movies.dat\", sep=\"::\", names=[\"movie_id\", \"title\", \"genres\"] ) Here, we do some simple data processing to fix the data types of the columns. users[\"user_id\"] = users[\"user_id\"].apply(lambda x: f\"user_{x}\") users[\"age_group\"] = users[\"age_group\"].apply(lambda x: f\"group_{x}\") users[\"occupation\"] = users[\"occupation\"].apply(lambda x: f\"occupation_{x}\") movies[\"movie_id\"] = movies[\"movie_id\"].apply(lambda x: f\"movie_{x}\") ratings[\"movie_id\"] = ratings[\"movie_id\"].apply(lambda x: f\"movie_{x}\") ratings[\"user_id\"] = ratings[\"user_id\"].apply(lambda x: f\"user_{x}\") ratings[\"rating\"] = ratings[\"rating\"].apply(lambda x: float(x)) Each movie has multiple genres. We split them into separate columns in the movies DataFrame. genres = [ \"Action\", \"Adventure\", \"Animation\", \"Children's\", \"Comedy\", \"Crime\", \"Documentary\", \"Drama\", \"Fantasy\", \"Film-Noir\", \"Horror\", \"Musical\", \"Mystery\", \"Romance\", \"Sci-Fi\", \"Thriller\", \"War\", \"Western\", ] for genre in genres: movies[genre] = movies[\"genres\"].apply( lambda values: int(genre in values.split(\"|\")) ) Transform the movie ratings data into sequences First, let's sort the the ratings data using the unix_timestamp, and then group the movie_id values and the rating values by user_id. The output DataFrame will have a record for each user_id, with two ordered lists (sorted by rating datetime): the movies they have rated, and their ratings of these movies. ratings_group = ratings.sort_values(by=[\"unix_timestamp\"]).groupby(\"user_id\") ratings_data = pd.DataFrame( data={ \"user_id\": list(ratings_group.groups.keys()), \"movie_ids\": list(ratings_group.movie_id.apply(list)), \"ratings\": list(ratings_group.rating.apply(list)), \"timestamps\": list(ratings_group.unix_timestamp.apply(list)), } ) Now, let's split the movie_ids list into a set of sequences of a fixed length. We do the same for the ratings. Set the sequence_length variable to change the length of the input sequence to the model. You can also change the step_size to control the number of sequences to generate for each user. sequence_length = 4 step_size = 2 def create_sequences(values, window_size, step_size): sequences = [] start_index = 0 while True: end_index = start_index + window_size seq = values[start_index:end_index] if len(seq) < window_size: seq = values[-window_size:] if len(seq) == window_size: sequences.append(seq) break sequences.append(seq) start_index += step_size return sequences ratings_data.movie_ids = ratings_data.movie_ids.apply( lambda ids: create_sequences(ids, sequence_length, step_size) ) ratings_data.ratings = ratings_data.ratings.apply( lambda ids: create_sequences(ids, sequence_length, step_size) ) del ratings_data[\"timestamps\"] After that, we process the output to have each sequence in a separate records in the DataFrame. In addition, we join the user features with the ratings data. ratings_data_movies = ratings_data[[\"user_id\", \"movie_ids\"]].explode( \"movie_ids\", ignore_index=True ) ratings_data_rating = ratings_data[[\"ratings\"]].explode(\"ratings\", ignore_index=True) ratings_data_transformed = pd.concat([ratings_data_movies, ratings_data_rating], axis=1) ratings_data_transformed = ratings_data_transformed.join( users.set_index(\"user_id\"), on=\"user_id\" ) ratings_data_transformed.movie_ids = ratings_data_transformed.movie_ids.apply( lambda x: \",\".join(x) ) ratings_data_transformed.ratings = ratings_data_transformed.ratings.apply( lambda x: \",\".join([str(v) for v in x]) ) del ratings_data_transformed[\"zip_code\"] ratings_data_transformed.rename( columns={\"movie_ids\": \"sequence_movie_ids\", \"ratings\": \"sequence_ratings\"}, inplace=True, ) With sequence_length of 4 and step_size of 2, we end up with 498,623 sequences. Finally, we split the data into training and testing splits, with 85% and 15% of the instances, respectively, and store them to CSV files. random_selection = np.random.rand(len(ratings_data_transformed.index)) <= 0.85 train_data = ratings_data_transformed[random_selection] test_data = ratings_data_transformed[~random_selection] train_data.to_csv(\"train_data.csv\", index=False, sep=\"|\", header=False) test_data.to_csv(\"test_data.csv\", index=False, sep=\"|\", header=False) Define metadata CSV_HEADER = list(ratings_data_transformed.columns) CATEGORICAL_FEATURES_WITH_VOCABULARY = { \"user_id\": list(users.user_id.unique()), \"movie_id\": list(movies.movie_id.unique()), \"sex\": list(users.sex.unique()), \"age_group\": list(users.age_group.unique()), \"occupation\": list(users.occupation.unique()), } USER_FEATURES = [\"sex\", \"age_group\", \"occupation\"] MOVIE_FEATURES = [\"genres\"] Create tf.data.Dataset for training and evaluation def get_dataset_from_csv(csv_file_path, shuffle=False, batch_size=128): def process(features): movie_ids_string = features[\"sequence_movie_ids\"] sequence_movie_ids = tf.strings.split(movie_ids_string, \",\").to_tensor() # The last movie id in the sequence is the target movie. features[\"target_movie_id\"] = sequence_movie_ids[:, -1] features[\"sequence_movie_ids\"] = sequence_movie_ids[:, :-1] ratings_string = features[\"sequence_ratings\"] sequence_ratings = tf.strings.to_number( tf.strings.split(ratings_string, \",\"), tf.dtypes.float32 ).to_tensor() # The last rating in the sequence is the target for the model to predict. target = sequence_ratings[:, -1] features[\"sequence_ratings\"] = sequence_ratings[:, :-1] return features, target dataset = tf.data.experimental.make_csv_dataset( csv_file_path, batch_size=batch_size, column_names=CSV_HEADER, num_epochs=1, header=False, field_delim=\"|\", shuffle=shuffle, ).map(process) return dataset Create model inputs def create_model_inputs(): return { \"user_id\": layers.Input(name=\"user_id\", shape=(1,), dtype=tf.string), \"sequence_movie_ids\": layers.Input( name=\"sequence_movie_ids\", shape=(sequence_length - 1,), dtype=tf.string ), \"target_movie_id\": layers.Input( name=\"target_movie_id\", shape=(1,), dtype=tf.string ), \"sequence_ratings\": layers.Input( name=\"sequence_ratings\", shape=(sequence_length - 1,), dtype=tf.float32 ), \"sex\": layers.Input(name=\"sex\", shape=(1,), dtype=tf.string), \"age_group\": layers.Input(name=\"age_group\", shape=(1,), dtype=tf.string), \"occupation\": layers.Input(name=\"occupation\", shape=(1,), dtype=tf.string), } Encode input features The encode_input_features method works as follows: Each categorical user feature is encoded using layers.Embedding, with embedding dimension equals to the square root of the vocabulary size of the feature. The embeddings of these features are concatenated to form a single input tensor. Each movie in the movie sequence and the target movie is encoded layers.Embedding, where the dimension size is the square root of the number of movies. A multi-hot genres vector for each movie is concatenated with its embedding vector, and processed using a non-linear layers.Dense to output a vector of the same movie embedding dimensions. A positional embedding is added to each movie embedding in the sequence, and then multiplied by its rating from the ratings sequence. The target movie embedding is concatenated to the sequence movie embeddings, producing a tensor with the shape of [batch size, sequence length, embedding size], as expected by the attention layer for the transformer architecture. The method returns a tuple of two elements: encoded_transformer_features and encoded_other_features. def encode_input_features( inputs, include_user_id=True, include_user_features=True, include_movie_features=True, ): encoded_transformer_features = [] encoded_other_features = [] other_feature_names = [] if include_user_id: other_feature_names.append(\"user_id\") if include_user_features: other_feature_names.extend(USER_FEATURES) ## Encode user features for feature_name in other_feature_names: # Convert the string input values into integer indices. vocabulary = CATEGORICAL_FEATURES_WITH_VOCABULARY[feature_name] idx = StringLookup(vocabulary=vocabulary, mask_token=None, num_oov_indices=0)( inputs[feature_name] ) # Compute embedding dimensions embedding_dims = int(math.sqrt(len(vocabulary))) # Create an embedding layer with the specified dimensions. embedding_encoder = layers.Embedding( input_dim=len(vocabulary), output_dim=embedding_dims, name=f\"{feature_name}_embedding\", ) # Convert the index values to embedding representations. encoded_other_features.append(embedding_encoder(idx)) ## Create a single embedding vector for the user features if len(encoded_other_features) > 1: encoded_other_features = layers.concatenate(encoded_other_features) elif len(encoded_other_features) == 1: encoded_other_features = encoded_other_features[0] else: encoded_other_features = None ## Create a movie embedding encoder movie_vocabulary = CATEGORICAL_FEATURES_WITH_VOCABULARY[\"movie_id\"] movie_embedding_dims = int(math.sqrt(len(movie_vocabulary))) # Create a lookup to convert string values to integer indices. movie_index_lookup = StringLookup( vocabulary=movie_vocabulary, mask_token=None, num_oov_indices=0, name=\"movie_index_lookup\", ) # Create an embedding layer with the specified dimensions. movie_embedding_encoder = layers.Embedding( input_dim=len(movie_vocabulary), output_dim=movie_embedding_dims, name=f\"movie_embedding\", ) # Create a vector lookup for movie genres. genre_vectors = movies[genres].to_numpy() movie_genres_lookup = layers.Embedding( input_dim=genre_vectors.shape[0], output_dim=genre_vectors.shape[1], embeddings_initializer=tf.keras.initializers.Constant(genre_vectors), trainable=False, name=\"genres_vector\", ) # Create a processing layer for genres. movie_embedding_processor = layers.Dense( units=movie_embedding_dims, activation=\"relu\", name=\"process_movie_embedding_with_genres\", ) ## Define a function to encode a given movie id. def encode_movie(movie_id): # Convert the string input values into integer indices. movie_idx = movie_index_lookup(movie_id) movie_embedding = movie_embedding_encoder(movie_idx) encoded_movie = movie_embedding if include_movie_features: movie_genres_vector = movie_genres_lookup(movie_idx) encoded_movie = movie_embedding_processor( layers.concatenate([movie_embedding, movie_genres_vector]) ) return encoded_movie ## Encoding target_movie_id target_movie_id = inputs[\"target_movie_id\"] encoded_target_movie = encode_movie(target_movie_id) ## Encoding sequence movie_ids. sequence_movies_ids = inputs[\"sequence_movie_ids\"] encoded_sequence_movies = encode_movie(sequence_movies_ids) # Create positional embedding. position_embedding_encoder = layers.Embedding( input_dim=sequence_length, output_dim=movie_embedding_dims, name=\"position_embedding\", ) positions = tf.range(start=0, limit=sequence_length - 1, delta=1) encodded_positions = position_embedding_encoder(positions) # Retrieve sequence ratings to incorporate them into the encoding of the movie. sequence_ratings = tf.expand_dims(inputs[\"sequence_ratings\"], -1) # Add the positional encoding to the movie encodings and multiply them by rating. encoded_sequence_movies_with_poistion_and_rating = layers.Multiply()( [(encoded_sequence_movies + encodded_positions), sequence_ratings] ) # Construct the transformer inputs. for encoded_movie in tf.unstack( encoded_sequence_movies_with_poistion_and_rating, axis=1 ): encoded_transformer_features.append(tf.expand_dims(encoded_movie, 1)) encoded_transformer_features.append(encoded_target_movie) encoded_transformer_features = layers.concatenate( encoded_transformer_features, axis=1 ) return encoded_transformer_features, encoded_other_features Create a BST model include_user_id = False include_user_features = False include_movie_features = False hidden_units = [256, 128] dropout_rate = 0.1 num_heads = 3 def create_model(): inputs = create_model_inputs() transformer_features, other_features = encode_input_features( inputs, include_user_id, include_user_features, include_movie_features ) # Create a multi-headed attention layer. attention_output = layers.MultiHeadAttention( num_heads=num_heads, key_dim=transformer_features.shape[2], dropout=dropout_rate )(transformer_features, transformer_features) # Transformer block. attention_output = layers.Dropout(dropout_rate)(attention_output) x1 = layers.Add()([transformer_features, attention_output]) x1 = layers.LayerNormalization()(x1) x2 = layers.LeakyReLU()(x1) x2 = layers.Dense(units=x2.shape[-1])(x2) x2 = layers.Dropout(dropout_rate)(x2) transformer_features = layers.Add()([x1, x2]) transformer_features = layers.LayerNormalization()(transformer_features) features = layers.Flatten()(transformer_features) # Included the other features. if other_features is not None: features = layers.concatenate( [features, layers.Reshape([other_features.shape[-1]])(other_features)] ) # Fully-connected layers. for num_units in hidden_units: features = layers.Dense(num_units)(features) features = layers.BatchNormalization()(features) features = layers.LeakyReLU()(features) features = layers.Dropout(dropout_rate)(features) outputs = layers.Dense(units=1)(features) model = keras.Model(inputs=inputs, outputs=outputs) return model model = create_model() Run training and evaluation experiment # Compile the model. model.compile( optimizer=keras.optimizers.Adagrad(learning_rate=0.01), loss=keras.losses.MeanSquaredError(), metrics=[keras.metrics.MeanAbsoluteError()], ) # Read the training data. train_dataset = get_dataset_from_csv(\"train_data.csv\", shuffle=True, batch_size=265) # Fit the model with the training data. model.fit(train_dataset, epochs=5) # Read the test data. test_dataset = get_dataset_from_csv(\"test_data.csv\", batch_size=265) # Evaluate the model on the test data. _, rmse = model.evaluate(test_dataset, verbose=0) print(f\"Test MAE: {round(rmse, 3)}\") Epoch 1/5 1598/1598 [==============================] - 46s 27ms/step - loss: 1.6617 - mean_absolute_error: 0.9981 Epoch 2/5 1598/1598 [==============================] - 43s 27ms/step - loss: 1.0282 - mean_absolute_error: 0.8101 Epoch 3/5 1598/1598 [==============================] - 43s 27ms/step - loss: 0.9609 - mean_absolute_error: 0.7812 Epoch 4/5 1598/1598 [==============================] - 43s 27ms/step - loss: 0.9272 - mean_absolute_error: 0.7675 Epoch 5/5 1598/1598 [==============================] - 43s 27ms/step - loss: 0.9062 - mean_absolute_error: 0.7588 Test MAE: 0.761 You should achieve a Mean Absolute Error (MAE) at or around 0.7 on the test data. Conclusion The BST model uses the Transformer layer in its architecture to capture the sequential signals underlying users’ behavior sequences for recommendation. You can try training this model with different configurations, for example, by increasing the input sequence length and training the model for a larger number of epochs. In addition, you can try including other features like movie release year and customer zipcode, and including cross features like sex X genre. Using Gated Residual and Variable Selection Networks for income level prediction. Introduction This example demonstrates the use of Gated Residual Networks (GRN) and Variable Selection Networks (VSN), proposed by Bryan Lim et al. in Temporal Fusion Transformers (TFT) for Interpretable Multi-horizon Time Series Forecasting, for structured data classification. GRNs give the flexibility to the model to apply non-linear processing only where needed. VSNs allow the model to softly remove any unnecessary noisy inputs which could negatively impact performance. Together, those techniques help improving the learning capacity of deep neural network models. Note that this example implements only the GRN and VSN components described in in the paper, rather than the whole TFT model, as GRN and VSN can be useful on their own for structured data learning tasks. To run the code you need to use TensorFlow 2.3 or higher. The dataset This example uses the United States Census Income Dataset provided by the UC Irvine Machine Learning Repository. The task is binary classification to determine whether a person makes over 50K a year. The dataset includes ~300K instances with 41 input features: 7 numerical features and 34 categorical features. Setup import math import numpy as np import pandas as pd import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Prepare the data First we load the data from the UCI Machine Learning Repository into a Pandas DataFrame. # Column names. CSV_HEADER = [ \"age\", \"class_of_worker\", \"detailed_industry_recode\", \"detailed_occupation_recode\", \"education\", \"wage_per_hour\", \"enroll_in_edu_inst_last_wk\", \"marital_stat\", \"major_industry_code\", \"major_occupation_code\", \"race\", \"hispanic_origin\", \"sex\", \"member_of_a_labor_union\", \"reason_for_unemployment\", \"full_or_part_time_employment_stat\", \"capital_gains\", \"capital_losses\", \"dividends_from_stocks\", \"tax_filer_stat\", \"region_of_previous_residence\", \"state_of_previous_residence\", \"detailed_household_and_family_stat\", \"detailed_household_summary_in_household\", \"instance_weight\", \"migration_code-change_in_msa\", \"migration_code-change_in_reg\", \"migration_code-move_within_reg\", \"live_in_this_house_1_year_ago\", \"migration_prev_res_in_sunbelt\", \"num_persons_worked_for_employer\", \"family_members_under_18\", \"country_of_birth_father\", \"country_of_birth_mother\", \"country_of_birth_self\", \"citizenship\", \"own_business_or_self_employed\", \"fill_inc_questionnaire_for_veteran's_admin\", \"veterans_benefits\", \"weeks_worked_in_year\", \"year\", \"income_level\", ] data_url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/census-income-mld/census-income.data.gz\" data = pd.read_csv(data_url, header=None, names=CSV_HEADER) test_data_url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/census-income-mld/census-income.test.gz\" test_data = pd.read_csv(test_data_url, header=None, names=CSV_HEADER) print(f\"Data shape: {data.shape}\") print(f\"Test data shape: {test_data.shape}\") Data shape: (199523, 42) Test data shape: (99762, 42) We convert the target column from string to integer. data[\"income_level\"] = data[\"income_level\"].apply( lambda x: 0 if x == \" - 50000.\" else 1 ) test_data[\"income_level\"] = test_data[\"income_level\"].apply( lambda x: 0 if x == \" - 50000.\" else 1 ) Then, We split the dataset into train and validation sets. random_selection = np.random.rand(len(data.index)) <= 0.85 train_data = data[random_selection] valid_data = data[~random_selection] Finally we store the train and test data splits locally to CSV files. train_data_file = \"train_data.csv\" valid_data_file = \"valid_data.csv\" test_data_file = \"test_data.csv\" train_data.to_csv(train_data_file, index=False, header=False) valid_data.to_csv(valid_data_file, index=False, header=False) test_data.to_csv(test_data_file, index=False, header=False) Define dataset metadata Here, we define the metadata of the dataset that will be useful for reading and parsing the data into input features, and encoding the input features with respect to their types. # Target feature name. TARGET_FEATURE_NAME = \"income_level\" # Weight column name. WEIGHT_COLUMN_NAME = \"instance_weight\" # Numeric feature names. NUMERIC_FEATURE_NAMES = [ \"age\", \"wage_per_hour\", \"capital_gains\", \"capital_losses\", \"dividends_from_stocks\", \"num_persons_worked_for_employer\", \"weeks_worked_in_year\", ] # Categorical features and their vocabulary lists. # Note that we add 'v=' as a prefix to all categorical feature values to make # sure that they are treated as strings. CATEGORICAL_FEATURES_WITH_VOCABULARY = { feature_name: sorted([str(value) for value in list(data[feature_name].unique())]) for feature_name in CSV_HEADER if feature_name not in list(NUMERIC_FEATURE_NAMES + [WEIGHT_COLUMN_NAME, TARGET_FEATURE_NAME]) } # All features names. FEATURE_NAMES = NUMERIC_FEATURE_NAMES + list( CATEGORICAL_FEATURES_WITH_VOCABULARY.keys() ) # Feature default values. COLUMN_DEFAULTS = [ [0.0] if feature_name in NUMERIC_FEATURE_NAMES + [TARGET_FEATURE_NAME, WEIGHT_COLUMN_NAME] else [\"NA\"] for feature_name in CSV_HEADER ] Create a tf.data.Dataset for training and evaluation We create an input function to read and parse the file, and convert features and labels into a [tf.data.Dataset](https://www.tensorflow.org/api_docs/python/tf/data/Dataset) for training and evaluation. from tensorflow.keras.layers import StringLookup def process(features, target): for feature_name in features: if feature_name in CATEGORICAL_FEATURES_WITH_VOCABULARY: # Cast categorical feature values to string. features[feature_name] = tf.cast(features[feature_name], tf.dtypes.string) # Get the instance weight. weight = features.pop(WEIGHT_COLUMN_NAME) return features, target, weight def get_dataset_from_csv(csv_file_path, shuffle=False, batch_size=128): dataset = tf.data.experimental.make_csv_dataset( csv_file_path, batch_size=batch_size, column_names=CSV_HEADER, column_defaults=COLUMN_DEFAULTS, label_name=TARGET_FEATURE_NAME, num_epochs=1, header=False, shuffle=shuffle, ).map(process) return dataset Create model inputs def create_model_inputs(): inputs = {} for feature_name in FEATURE_NAMES: if feature_name in NUMERIC_FEATURE_NAMES: inputs[feature_name] = layers.Input( name=feature_name, shape=(), dtype=tf.float32 ) else: inputs[feature_name] = layers.Input( name=feature_name, shape=(), dtype=tf.string ) return inputs Encode input features For categorical features, we encode them using layers.Embedding using the encoding_size as the embedding dimensions. For the numerical features, we apply linear transformation using layers.Dense to project each feature into encoding_size-dimensional vector. Thus, all the encoded features will have the same dimensionality. def encode_inputs(inputs, encoding_size): encoded_features = [] for feature_name in inputs: if feature_name in CATEGORICAL_FEATURES_WITH_VOCABULARY: vocabulary = CATEGORICAL_FEATURES_WITH_VOCABULARY[feature_name] # Create a lookup to convert a string values to an integer indices. # Since we are not using a mask token nor expecting any out of vocabulary # (oov) token, we set mask_token to None and num_oov_indices to 0. index = StringLookup( vocabulary=vocabulary, mask_token=None, num_oov_indices=0 ) # Convert the string input values into integer indices. value_index = index(inputs[feature_name]) # Create an embedding layer with the specified dimensions embedding_ecoder = layers.Embedding( input_dim=len(vocabulary), output_dim=encoding_size ) # Convert the index values to embedding representations. encoded_feature = embedding_ecoder(value_index) else: # Project the numeric feature to encoding_size using linear transformation. encoded_feature = tf.expand_dims(inputs[feature_name], -1) encoded_feature = layers.Dense(units=encoding_size)(encoded_feature) encoded_features.append(encoded_feature) return encoded_features Implement the Gated Linear Unit Gated Linear Units (GLUs) provide the flexibility to suppress input that are not relevant for a given task. class GatedLinearUnit(layers.Layer): def __init__(self, units): super(GatedLinearUnit, self).__init__() self.linear = layers.Dense(units) self.sigmoid = layers.Dense(units, activation=\"sigmoid\") def call(self, inputs): return self.linear(inputs) * self.sigmoid(inputs) Implement the Gated Residual Network The Gated Residual Network (GRN) works as follows: Applies the nonlinear ELU transformation to the inputs. Applies linear transformation followed by dropout. Applies GLU and adds the original inputs to the output of the GLU to perform skip (residual) connection. Applies layer normalization and produces the output. class GatedResidualNetwork(layers.Layer): def __init__(self, units, dropout_rate): super(GatedResidualNetwork, self).__init__() self.units = units self.elu_dense = layers.Dense(units, activation=\"elu\") self.linear_dense = layers.Dense(units) self.dropout = layers.Dropout(dropout_rate) self.gated_linear_unit = GatedLinearUnit(units) self.layer_norm = layers.LayerNormalization() self.project = layers.Dense(units) def call(self, inputs): x = self.elu_dense(inputs) x = self.linear_dense(x) x = self.dropout(x) if inputs.shape[-1] != self.units: inputs = self.project(inputs) x = inputs + self.gated_linear_unit(x) x = self.layer_norm(x) return x Implement the Variable Selection Network The Variable Selection Network (VSN) works as follows: Applies a GRN to each feature individually. Applies a GRN on the concatenation of all the features, followed by a softmax to produce feature weights. Produces a weighted sum of the output of the individual GRN. Note that the output of the VSN is [batch_size, encoding_size], regardless of the number of the input features. class VariableSelection(layers.Layer): def __init__(self, num_features, units, dropout_rate): super(VariableSelection, self).__init__() self.grns = list() # Create a GRN for each feature independently for idx in range(num_features): grn = GatedResidualNetwork(units, dropout_rate) self.grns.append(grn) # Create a GRN for the concatenation of all the features self.grn_concat = GatedResidualNetwork(units, dropout_rate) self.softmax = layers.Dense(units=num_features, activation=\"softmax\") def call(self, inputs): v = layers.concatenate(inputs) v = self.grn_concat(v) v = tf.expand_dims(self.softmax(v), axis=-1) x = [] for idx, input in enumerate(inputs): x.append(self.grns[idx](input)) x = tf.stack(x, axis=1) outputs = tf.squeeze(tf.matmul(v, x, transpose_a=True), axis=1) return outputs Create Gated Residual and Variable Selection Networks model def create_model(encoding_size): inputs = create_model_inputs() feature_list = encode_inputs(inputs, encoding_size) num_features = len(feature_list) features = VariableSelection(num_features, encoding_size, dropout_rate)( feature_list ) outputs = layers.Dense(units=1, activation=\"sigmoid\")(features) model = keras.Model(inputs=inputs, outputs=outputs) return model Compile, train, and evaluate the model learning_rate = 0.001 dropout_rate = 0.15 batch_size = 265 num_epochs = 20 encoding_size = 16 model = create_model(encoding_size) model.compile( optimizer=keras.optimizers.Adam(learning_rate=learning_rate), loss=keras.losses.BinaryCrossentropy(), metrics=[keras.metrics.BinaryAccuracy(name=\"accuracy\")], ) # Create an early stopping callback. early_stopping = tf.keras.callbacks.EarlyStopping( monitor=\"val_loss\", patience=5, restore_best_weights=True ) print(\"Start training the model...\") train_dataset = get_dataset_from_csv( train_data_file, shuffle=True, batch_size=batch_size ) valid_dataset = get_dataset_from_csv(valid_data_file, batch_size=batch_size) model.fit( train_dataset, epochs=num_epochs, validation_data=valid_dataset, callbacks=[early_stopping], ) print(\"Model training finished.\") print(\"Evaluating model performance...\") test_dataset = get_dataset_from_csv(test_data_file, batch_size=batch_size) _, accuracy = model.evaluate(test_dataset) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") Start training the model... Epoch 1/20 641/641 [==============================] - 26s 22ms/step - loss: 317.7028 - accuracy: 0.9353 - val_loss: 230.1805 - val_accuracy: 0.9497 Epoch 2/20 641/641 [==============================] - 13s 19ms/step - loss: 231.4161 - accuracy: 0.9506 - val_loss: 224.7825 - val_accuracy: 0.9498 Epoch 3/20 641/641 [==============================] - 12s 19ms/step - loss: 226.8173 - accuracy: 0.9503 - val_loss: 223.0818 - val_accuracy: 0.9508 Epoch 4/20 641/641 [==============================] - 13s 19ms/step - loss: 224.1516 - accuracy: 0.9507 - val_loss: 221.8637 - val_accuracy: 0.9509 Epoch 5/20 641/641 [==============================] - 13s 19ms/step - loss: 223.9696 - accuracy: 0.9507 - val_loss: 217.8728 - val_accuracy: 0.9513 Epoch 6/20 641/641 [==============================] - 13s 19ms/step - loss: 220.7267 - accuracy: 0.9508 - val_loss: 220.2448 - val_accuracy: 0.9516 Epoch 7/20 641/641 [==============================] - 13s 19ms/step - loss: 219.7464 - accuracy: 0.9514 - val_loss: 216.4628 - val_accuracy: 0.9516 Epoch 8/20 641/641 [==============================] - 13s 19ms/step - loss: 218.7294 - accuracy: 0.9517 - val_loss: 215.2192 - val_accuracy: 0.9519 Epoch 9/20 641/641 [==============================] - 12s 19ms/step - loss: 218.3938 - accuracy: 0.9516 - val_loss: 217.1790 - val_accuracy: 0.9514 Epoch 10/20 641/641 [==============================] - 13s 19ms/step - loss: 217.2871 - accuracy: 0.9522 - val_loss: 213.4623 - val_accuracy: 0.9523 Epoch 11/20 641/641 [==============================] - 13s 19ms/step - loss: 215.0476 - accuracy: 0.9522 - val_loss: 211.6762 - val_accuracy: 0.9523 Epoch 12/20 641/641 [==============================] - 13s 19ms/step - loss: 213.2402 - accuracy: 0.9527 - val_loss: 212.2001 - val_accuracy: 0.9525 Epoch 13/20 641/641 [==============================] - 13s 20ms/step - loss: 212.8123 - accuracy: 0.9530 - val_loss: 207.9878 - val_accuracy: 0.9538 Epoch 14/20 641/641 [==============================] - 13s 19ms/step - loss: 208.4605 - accuracy: 0.9541 - val_loss: 208.0063 - val_accuracy: 0.9543 Epoch 15/20 641/641 [==============================] - 13s 19ms/step - loss: 211.9185 - accuracy: 0.9533 - val_loss: 208.2112 - val_accuracy: 0.9540 Epoch 16/20 641/641 [==============================] - 13s 19ms/step - loss: 207.7694 - accuracy: 0.9544 - val_loss: 207.3279 - val_accuracy: 0.9547 Epoch 17/20 641/641 [==============================] - 13s 19ms/step - loss: 208.6964 - accuracy: 0.9540 - val_loss: 204.3082 - val_accuracy: 0.9553 Epoch 18/20 641/641 [==============================] - 13s 19ms/step - loss: 207.2199 - accuracy: 0.9547 - val_loss: 206.4799 - val_accuracy: 0.9549 Epoch 19/20 641/641 [==============================] - 13s 19ms/step - loss: 206.7960 - accuracy: 0.9548 - val_loss: 206.0898 - val_accuracy: 0.9555 Epoch 20/20 641/641 [==============================] - 13s 20ms/step - loss: 206.2721 - accuracy: 0.9547 - val_loss: 206.6541 - val_accuracy: 0.9549 Model training finished. Evaluating model performance... 377/377 [==============================] - 5s 11ms/step - loss: 206.3511 - accuracy: 0.9541 Test accuracy: 95.41% You should achieve more than 95% accuracy on the test set. To increase the learning capacity of the model, you can try increasing the encoding_size value, or stacking multiple GRN layers on top of the VSN layer. This may require to also increase the dropout_rate value to avoid overfitting. How to train differentiable decision trees for end-to-end learning in deep neural networks. Introduction This example provides an implementation of the Deep Neural Decision Forest model introduced by P. Kontschieder et al. for structured data classification. It demonstrates how to build a stochastic and differentiable decision tree model, train it end-to-end, and unify decision trees with deep representation learning. The dataset This example uses the United States Census Income Dataset provided by the UC Irvine Machine Learning Repository. The task is binary classification to predict whether a person is likely to be making over USD 50,000 a year. The dataset includes 48,842 instances with 14 input features (such as age, work class, education, occupation, and so on): 5 numerical features and 9 categorical features. Setup import tensorflow as tf import numpy as np import pandas as pd from tensorflow import keras from tensorflow.keras import layers import math Prepare the data CSV_HEADER = [ \"age\", \"workclass\", \"fnlwgt\", \"education\", \"education_num\", \"marital_status\", \"occupation\", \"relationship\", \"race\", \"gender\", \"capital_gain\", \"capital_loss\", \"hours_per_week\", \"native_country\", \"income_bracket\", ] train_data_url = ( \"https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data\" ) train_data = pd.read_csv(train_data_url, header=None, names=CSV_HEADER) test_data_url = ( \"https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test\" ) test_data = pd.read_csv(test_data_url, header=None, names=CSV_HEADER) print(f\"Train dataset shape: {train_data.shape}\") print(f\"Test dataset shape: {test_data.shape}\") Train dataset shape: (32561, 15) Test dataset shape: (16282, 15) Remove the first record (because it is not a valid data example) and a trailing 'dot' in the class labels. test_data = test_data[1:] test_data.income_bracket = test_data.income_bracket.apply( lambda value: value.replace(\".\", \"\") ) We store the training and test data splits locally as CSV files. train_data_file = \"train_data.csv\" test_data_file = \"test_data.csv\" train_data.to_csv(train_data_file, index=False, header=False) test_data.to_csv(test_data_file, index=False, header=False) Define dataset metadata Here, we define the metadata of the dataset that will be useful for reading and parsing and encoding input features. # A list of the numerical feature names. NUMERIC_FEATURE_NAMES = [ \"age\", \"education_num\", \"capital_gain\", \"capital_loss\", \"hours_per_week\", ] # A dictionary of the categorical features and their vocabulary. CATEGORICAL_FEATURES_WITH_VOCABULARY = { \"workclass\": sorted(list(train_data[\"workclass\"].unique())), \"education\": sorted(list(train_data[\"education\"].unique())), \"marital_status\": sorted(list(train_data[\"marital_status\"].unique())), \"occupation\": sorted(list(train_data[\"occupation\"].unique())), \"relationship\": sorted(list(train_data[\"relationship\"].unique())), \"race\": sorted(list(train_data[\"race\"].unique())), \"gender\": sorted(list(train_data[\"gender\"].unique())), \"native_country\": sorted(list(train_data[\"native_country\"].unique())), } # A list of the columns to ignore from the dataset. IGNORE_COLUMN_NAMES = [\"fnlwgt\"] # A list of the categorical feature names. CATEGORICAL_FEATURE_NAMES = list(CATEGORICAL_FEATURES_WITH_VOCABULARY.keys()) # A list of all the input features. FEATURE_NAMES = NUMERIC_FEATURE_NAMES + CATEGORICAL_FEATURE_NAMES # A list of column default values for each feature. COLUMN_DEFAULTS = [ [0.0] if feature_name in NUMERIC_FEATURE_NAMES + IGNORE_COLUMN_NAMES else [\"NA\"] for feature_name in CSV_HEADER ] # The name of the target feature. TARGET_FEATURE_NAME = \"income_bracket\" # A list of the labels of the target features. TARGET_LABELS = [\" <=50K\", \" >50K\"] Create tf.data.Dataset objects for training and validation We create an input function to read and parse the file, and convert features and labels into a [tf.data.Dataset](https://www.tensorflow.org/api_docs/python/tf/data/Dataset) for training and validation. We also preprocess the input by mapping the target label to an index. from tensorflow.keras.layers import StringLookup target_label_lookup = StringLookup( vocabulary=TARGET_LABELS, mask_token=None, num_oov_indices=0 ) def get_dataset_from_csv(csv_file_path, shuffle=False, batch_size=128): dataset = tf.data.experimental.make_csv_dataset( csv_file_path, batch_size=batch_size, column_names=CSV_HEADER, column_defaults=COLUMN_DEFAULTS, label_name=TARGET_FEATURE_NAME, num_epochs=1, header=False, na_value=\"?\", shuffle=shuffle, ).map(lambda features, target: (features, target_label_lookup(target))) return dataset.cache() Create model inputs def create_model_inputs(): inputs = {} for feature_name in FEATURE_NAMES: if feature_name in NUMERIC_FEATURE_NAMES: inputs[feature_name] = layers.Input( name=feature_name, shape=(), dtype=tf.float32 ) else: inputs[feature_name] = layers.Input( name=feature_name, shape=(), dtype=tf.string ) return inputs Encode input features def encode_inputs(inputs): encoded_features = [] for feature_name in inputs: if feature_name in CATEGORICAL_FEATURE_NAMES: vocabulary = CATEGORICAL_FEATURES_WITH_VOCABULARY[feature_name] # Create a lookup to convert a string values to an integer indices. # Since we are not using a mask token, nor expecting any out of vocabulary # (oov) token, we set mask_token to None and num_oov_indices to 0. lookup = StringLookup( vocabulary=vocabulary, mask_token=None, num_oov_indices=0 ) # Convert the string input values into integer indices. value_index = lookup(inputs[feature_name]) embedding_dims = int(math.sqrt(lookup.vocabulary_size())) # Create an embedding layer with the specified dimensions. embedding = layers.Embedding( input_dim=lookup.vocabulary_size(), output_dim=embedding_dims ) # Convert the index values to embedding representations. encoded_feature = embedding(value_index) else: # Use the numerical features as-is. encoded_feature = inputs[feature_name] if inputs[feature_name].shape[-1] is None: encoded_feature = tf.expand_dims(encoded_feature, -1) encoded_features.append(encoded_feature) encoded_features = layers.concatenate(encoded_features) return encoded_features Deep Neural Decision Tree A neural decision tree model has two sets of weights to learn. The first set is pi, which represents the probability distribution of the classes in the tree leaves. The second set is the weights of the routing layer decision_fn, which represents the probability of going to each leave. The forward pass of the model works as follows: The model expects input features as a single vector encoding all the features of an instance in the batch. This vector can be generated from a Convolution Neural Network (CNN) applied to images or dense transformations applied to structured data features. The model first applies a used_features_mask to randomly select a subset of input features to use. Then, the model computes the probabilities (mu) for the input instances to reach the tree leaves by iteratively performing a stochastic routing throughout the tree levels. Finally, the probabilities of reaching the leaves are combined by the class probabilities at the leaves to produce the final outputs. class NeuralDecisionTree(keras.Model): def __init__(self, depth, num_features, used_features_rate, num_classes): super(NeuralDecisionTree, self).__init__() self.depth = depth self.num_leaves = 2 ** depth self.num_classes = num_classes # Create a mask for the randomly selected features. num_used_features = int(num_features * used_features_rate) one_hot = np.eye(num_features) sampled_feature_indicies = np.random.choice( np.arange(num_features), num_used_features, replace=False ) self.used_features_mask = one_hot[sampled_feature_indicies] # Initialize the weights of the classes in leaves. self.pi = tf.Variable( initial_value=tf.random_normal_initializer()( shape=[self.num_leaves, self.num_classes] ), dtype=\"float32\", trainable=True, ) # Initialize the stochastic routing layer. self.decision_fn = layers.Dense( units=self.num_leaves, activation=\"sigmoid\", name=\"decision\" ) def call(self, features): batch_size = tf.shape(features)[0] # Apply the feature mask to the input features. features = tf.matmul( features, self.used_features_mask, transpose_b=True ) # [batch_size, num_used_features] # Compute the routing probabilities. decisions = tf.expand_dims( self.decision_fn(features), axis=2 ) # [batch_size, num_leaves, 1] # Concatenate the routing probabilities with their complements. decisions = layers.concatenate( [decisions, 1 - decisions], axis=2 ) # [batch_size, num_leaves, 2] mu = tf.ones([batch_size, 1, 1]) begin_idx = 1 end_idx = 2 # Traverse the tree in breadth-first order. for level in range(self.depth): mu = tf.reshape(mu, [batch_size, -1, 1]) # [batch_size, 2 ** level, 1] mu = tf.tile(mu, (1, 1, 2)) # [batch_size, 2 ** level, 2] level_decisions = decisions[ :, begin_idx:end_idx, : ] # [batch_size, 2 ** level, 2] mu = mu * level_decisions # [batch_size, 2**level, 2] begin_idx = end_idx end_idx = begin_idx + 2 ** (level + 1) mu = tf.reshape(mu, [batch_size, self.num_leaves]) # [batch_size, num_leaves] probabilities = keras.activations.softmax(self.pi) # [num_leaves, num_classes] outputs = tf.matmul(mu, probabilities) # [batch_size, num_classes] return outputs Deep Neural Decision Forest The neural decision forest model consists of a set of neural decision trees that are trained simultaneously. The output of the forest model is the average outputs of its trees. class NeuralDecisionForest(keras.Model): def __init__(self, num_trees, depth, num_features, used_features_rate, num_classes): super(NeuralDecisionForest, self).__init__() self.ensemble = [] # Initialize the ensemble by adding NeuralDecisionTree instances. # Each tree will have its own randomly selected input features to use. for _ in range(num_trees): self.ensemble.append( NeuralDecisionTree(depth, num_features, used_features_rate, num_classes) ) def call(self, inputs): # Initialize the outputs: a [batch_size, num_classes] matrix of zeros. batch_size = tf.shape(inputs)[0] outputs = tf.zeros([batch_size, num_classes]) # Aggregate the outputs of trees in the ensemble. for tree in self.ensemble: outputs += tree(inputs) # Divide the outputs by the ensemble size to get the average. outputs /= len(self.ensemble) return outputs Finally, let's set up the code that will train and evaluate the model. learning_rate = 0.01 batch_size = 265 num_epochs = 10 hidden_units = [64, 64] def run_experiment(model): model.compile( optimizer=keras.optimizers.Adam(learning_rate=learning_rate), loss=keras.losses.SparseCategoricalCrossentropy(), metrics=[keras.metrics.SparseCategoricalAccuracy()], ) print(\"Start training the model...\") train_dataset = get_dataset_from_csv( train_data_file, shuffle=True, batch_size=batch_size ) model.fit(train_dataset, epochs=num_epochs) print(\"Model training finished\") print(\"Evaluating the model on the test data...\") test_dataset = get_dataset_from_csv(test_data_file, batch_size=batch_size) _, accuracy = model.evaluate(test_dataset) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") Experiment 1: train a decision tree model In this experiment, we train a single neural decision tree model where we use all input features. num_trees = 10 depth = 10 used_features_rate = 1.0 num_classes = len(TARGET_LABELS) def create_tree_model(): inputs = create_model_inputs() features = encode_inputs(inputs) features = layers.BatchNormalization()(features) num_features = features.shape[1] tree = NeuralDecisionTree(depth, num_features, used_features_rate, num_classes) outputs = tree(features) model = keras.Model(inputs=inputs, outputs=outputs) return model tree_model = create_tree_model() run_experiment(tree_model) 123/123 [==============================] - 3s 9ms/step - loss: 0.5326 - sparse_categorical_accuracy: 0.7838 Epoch 2/10 123/123 [==============================] - 1s 9ms/step - loss: 0.3406 - sparse_categorical_accuracy: 0.8469 Epoch 3/10 123/123 [==============================] - 1s 9ms/step - loss: 0.3254 - sparse_categorical_accuracy: 0.8499 Epoch 4/10 123/123 [==============================] - 1s 9ms/step - loss: 0.3188 - sparse_categorical_accuracy: 0.8539 Epoch 5/10 123/123 [==============================] - 1s 9ms/step - loss: 0.3137 - sparse_categorical_accuracy: 0.8573 Epoch 6/10 123/123 [==============================] - 1s 9ms/step - loss: 0.3091 - sparse_categorical_accuracy: 0.8581 Epoch 7/10 123/123 [==============================] - 1s 9ms/step - loss: 0.3039 - sparse_categorical_accuracy: 0.8596 Epoch 8/10 123/123 [==============================] - 1s 9ms/step - loss: 0.2991 - sparse_categorical_accuracy: 0.8633 Epoch 9/10 123/123 [==============================] - 1s 9ms/step - loss: 0.2935 - sparse_categorical_accuracy: 0.8667 Epoch 10/10 123/123 [==============================] - 1s 9ms/step - loss: 0.2877 - sparse_categorical_accuracy: 0.8708 Model training finished Evaluating the model on the test data... 62/62 [==============================] - 1s 5ms/step - loss: 0.3314 - sparse_categorical_accuracy: 0.8471 Test accuracy: 84.71% Experiment 2: train a forest model In this experiment, we train a neural decision forest with num_trees trees where each tree uses randomly selected 50% of the input features. You can control the number of features to be used in each tree by setting the used_features_rate variable. In addition, we set the depth to 5 instead of 10 compared to the previous experiment. num_trees = 25 depth = 5 used_features_rate = 0.5 def create_forest_model(): inputs = create_model_inputs() features = encode_inputs(inputs) features = layers.BatchNormalization()(features) num_features = features.shape[1] forest_model = NeuralDecisionForest( num_trees, depth, num_features, used_features_rate, num_classes ) outputs = forest_model(features) model = keras.Model(inputs=inputs, outputs=outputs) return model forest_model = create_forest_model() run_experiment(forest_model) Start training the model... Epoch 1/10 123/123 [==============================] - 9s 7ms/step - loss: 0.5523 - sparse_categorical_accuracy: 0.7872 Epoch 2/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3435 - sparse_categorical_accuracy: 0.8465 Epoch 3/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3260 - sparse_categorical_accuracy: 0.8514 Epoch 4/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3197 - sparse_categorical_accuracy: 0.8533 Epoch 5/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3160 - sparse_categorical_accuracy: 0.8535 Epoch 6/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3133 - sparse_categorical_accuracy: 0.8545 Epoch 7/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3110 - sparse_categorical_accuracy: 0.8556 Epoch 8/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3088 - sparse_categorical_accuracy: 0.8559 Epoch 9/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3066 - sparse_categorical_accuracy: 0.8573 Epoch 10/10 123/123 [==============================] - 1s 6ms/step - loss: 0.3048 - sparse_categorical_accuracy: 0.8573 Model training finished Evaluating the model on the test data... 62/62 [==============================] - 2s 5ms/step - loss: 0.3140 - sparse_categorical_accuracy: 0.8533 Test accuracy: 85.33% Recommending movies using a model trained on Movielens dataset. Introduction This example demonstrates Collaborative filtering using the Movielens dataset to recommend movies to users. The MovieLens ratings dataset lists the ratings given by a set of users to a set of movies. Our goal is to be able to predict ratings for movies a user has not yet watched. The movies with the highest predicted ratings can then be recommended to the user. The steps in the model are as follows: Map user ID to a \"user vector\" via an embedding matrix Map movie ID to a \"movie vector\" via an embedding matrix Compute the dot product between the user vector and movie vector, to obtain the a match score between the user and the movie (predicted rating). Train the embeddings via gradient descent using all known user-movie pairs. References: Collaborative Filtering Neural Collaborative Filtering import pandas as pd import numpy as np from zipfile import ZipFile import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from pathlib import Path import matplotlib.pyplot as plt First, load the data and apply preprocessing # Download the actual data from http://files.grouplens.org/datasets/movielens/ml-latest-small.zip\" # Use the ratings.csv file movielens_data_file_url = ( \"http://files.grouplens.org/datasets/movielens/ml-latest-small.zip\" ) movielens_zipped_file = keras.utils.get_file( \"ml-latest-small.zip\", movielens_data_file_url, extract=False ) keras_datasets_path = Path(movielens_zipped_file).parents[0] movielens_dir = keras_datasets_path / \"ml-latest-small\" # Only extract the data the first time the script is run. if not movielens_dir.exists(): with ZipFile(movielens_zipped_file, \"r\") as zip: # Extract files print(\"Extracting all the files now...\") zip.extractall(path=keras_datasets_path) print(\"Done!\") ratings_file = movielens_dir / \"ratings.csv\" df = pd.read_csv(ratings_file) First, need to perform some preprocessing to encode users and movies as integer indices. user_ids = df[\"userId\"].unique().tolist() user2user_encoded = {x: i for i, x in enumerate(user_ids)} userencoded2user = {i: x for i, x in enumerate(user_ids)} movie_ids = df[\"movieId\"].unique().tolist() movie2movie_encoded = {x: i for i, x in enumerate(movie_ids)} movie_encoded2movie = {i: x for i, x in enumerate(movie_ids)} df[\"user\"] = df[\"userId\"].map(user2user_encoded) df[\"movie\"] = df[\"movieId\"].map(movie2movie_encoded) num_users = len(user2user_encoded) num_movies = len(movie_encoded2movie) df[\"rating\"] = df[\"rating\"].values.astype(np.float32) # min and max ratings will be used to normalize the ratings later min_rating = min(df[\"rating\"]) max_rating = max(df[\"rating\"]) print( \"Number of users: {}, Number of Movies: {}, Min rating: {}, Max rating: {}\".format( num_users, num_movies, min_rating, max_rating ) ) Number of users: 610, Number of Movies: 9724, Min rating: 0.5, Max rating: 5.0 Prepare training and validation data df = df.sample(frac=1, random_state=42) x = df[[\"user\", \"movie\"]].values # Normalize the targets between 0 and 1. Makes it easy to train. y = df[\"rating\"].apply(lambda x: (x - min_rating) / (max_rating - min_rating)).values # Assuming training on 90% of the data and validating on 10%. train_indices = int(0.9 * df.shape[0]) x_train, x_val, y_train, y_val = ( x[:train_indices], x[train_indices:], y[:train_indices], y[train_indices:], ) Create the model We embed both users and movies in to 50-dimensional vectors. The model computes a match score between user and movie embeddings via a dot product, and adds a per-movie and per-user bias. The match score is scaled to the [0, 1] interval via a sigmoid (since our ratings are normalized to this range). EMBEDDING_SIZE = 50 class RecommenderNet(keras.Model): def __init__(self, num_users, num_movies, embedding_size, **kwargs): super(RecommenderNet, self).__init__(**kwargs) self.num_users = num_users self.num_movies = num_movies self.embedding_size = embedding_size self.user_embedding = layers.Embedding( num_users, embedding_size, embeddings_initializer=\"he_normal\", embeddings_regularizer=keras.regularizers.l2(1e-6), ) self.user_bias = layers.Embedding(num_users, 1) self.movie_embedding = layers.Embedding( num_movies, embedding_size, embeddings_initializer=\"he_normal\", embeddings_regularizer=keras.regularizers.l2(1e-6), ) self.movie_bias = layers.Embedding(num_movies, 1) def call(self, inputs): user_vector = self.user_embedding(inputs[:, 0]) user_bias = self.user_bias(inputs[:, 0]) movie_vector = self.movie_embedding(inputs[:, 1]) movie_bias = self.movie_bias(inputs[:, 1]) dot_user_movie = tf.tensordot(user_vector, movie_vector, 2) # Add all the components (including bias) x = dot_user_movie + user_bias + movie_bias # The sigmoid activation forces the rating to between 0 and 1 return tf.nn.sigmoid(x) model = RecommenderNet(num_users, num_movies, EMBEDDING_SIZE) model.compile( loss=tf.keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adam(lr=0.001) ) Train the model based on the data split history = model.fit( x=x_train, y=y_train, batch_size=64, epochs=5, verbose=1, validation_data=(x_val, y_val), ) Epoch 1/5 1418/1418 [==============================] - 6s 4ms/step - loss: 0.6368 - val_loss: 0.6206 Epoch 2/5 1418/1418 [==============================] - 7s 5ms/step - loss: 0.6131 - val_loss: 0.6176 Epoch 3/5 1418/1418 [==============================] - 6s 4ms/step - loss: 0.6083 - val_loss: 0.6146 Epoch 4/5 1418/1418 [==============================] - 6s 4ms/step - loss: 0.6072 - val_loss: 0.6131 Epoch 5/5 1418/1418 [==============================] - 6s 4ms/step - loss: 0.6075 - val_loss: 0.6150 Plot training and validation loss 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() png Show top 10 movie recommendations to a user movie_df = pd.read_csv(movielens_dir / \"movies.csv\") # Let us get a user and see the top recommendations. user_id = df.userId.sample(1).iloc[0] movies_watched_by_user = df[df.userId == user_id] movies_not_watched = movie_df[ ~movie_df[\"movieId\"].isin(movies_watched_by_user.movieId.values) ][\"movieId\"] movies_not_watched = list( set(movies_not_watched).intersection(set(movie2movie_encoded.keys())) ) movies_not_watched = [[movie2movie_encoded.get(x)] for x in movies_not_watched] user_encoder = user2user_encoded.get(user_id) user_movie_array = np.hstack( ([[user_encoder]] * len(movies_not_watched), movies_not_watched) ) ratings = model.predict(user_movie_array).flatten() top_ratings_indices = ratings.argsort()[-10:][::-1] recommended_movie_ids = [ movie_encoded2movie.get(movies_not_watched[x][0]) for x in top_ratings_indices ] print(\"Showing recommendations for user: {}\".format(user_id)) print(\"====\" * 9) print(\"Movies with high ratings from user\") print(\"----\" * 8) top_movies_user = ( movies_watched_by_user.sort_values(by=\"rating\", ascending=False) .head(5) .movieId.values ) movie_df_rows = movie_df[movie_df[\"movieId\"].isin(top_movies_user)] for row in movie_df_rows.itertuples(): print(row.title, \":\", row.genres) print(\"----\" * 8) print(\"Top 10 movie recommendations\") print(\"----\" * 8) recommended_movies = movie_df[movie_df[\"movieId\"].isin(recommended_movie_ids)] for row in recommended_movies.itertuples(): print(row.title, \":\", row.genres) Showing recommendations for user: 474 ==================================== Movies with high ratings from user -------------------------------- Fugitive, The (1993) : Thriller Remains of the Day, The (1993) : Drama|Romance West Side Story (1961) : Drama|Musical|Romance X2: X-Men United (2003) : Action|Adventure|Sci-Fi|Thriller Spider-Man 2 (2004) : Action|Adventure|Sci-Fi|IMAX -------------------------------- Top 10 movie recommendations -------------------------------- Dazed and Confused (1993) : Comedy Ghost in the Shell (Kôkaku kidôtai) (1995) : Animation|Sci-Fi Drugstore Cowboy (1989) : Crime|Drama Road Warrior, The (Mad Max 2) (1981) : Action|Adventure|Sci-Fi|Thriller Dark Knight, The (2008) : Action|Crime|Drama|IMAX Inglourious Basterds (2009) : Action|Drama|War Up (2009) : Adventure|Animation|Children|Drama Dark Knight Rises, The (2012) : Action|Adventure|Crime|IMAX Star Wars: Episode VII - The Force Awakens (2015) : Action|Adventure|Fantasy|Sci-Fi|IMAX Thor: Ragnarok (2017) : Action|Adventure|Sci-Fi Demonstration of how to handle highly imbalanced classification problems. Introduction This example looks at the Kaggle Credit Card Fraud Detection dataset to demonstrate how to train a classification model on data with highly imbalanced classes. First, vectorize the CSV data import csv import numpy as np # Get the real data from https://www.kaggle.com/mlg-ulb/creditcardfraud/ fname = \"/Users/fchollet/Downloads/creditcard.csv\" all_features = [] all_targets = [] with open(fname) as f: for i, line in enumerate(f): if i == 0: print(\"HEADER:\", line.strip()) continue # Skip header fields = line.strip().split(\",\") all_features.append([float(v.replace('\"', \"\")) for v in fields[:-1]]) all_targets.append([int(fields[-1].replace('\"', \"\"))]) if i == 1: print(\"EXAMPLE FEATURES:\", all_features[-1]) features = np.array(all_features, dtype=\"float32\") targets = np.array(all_targets, dtype=\"uint8\") print(\"features.shape:\", features.shape) print(\"targets.shape:\", targets.shape) HEADER: \"Time\",\"V1\",\"V2\",\"V3\",\"V4\",\"V5\",\"V6\",\"V7\",\"V8\",\"V9\",\"V10\",\"V11\",\"V12\",\"V13\",\"V14\",\"V15\",\"V16\",\"V17\",\"V18\",\"V19\",\"V20\",\"V21\",\"V22\",\"V23\",\"V24\",\"V25\",\"V26\",\"V27\",\"V28\",\"Amount\",\"Class\" EXAMPLE FEATURES: [0.0, -1.3598071336738, -0.0727811733098497, 2.53634673796914, 1.37815522427443, -0.338320769942518, 0.462387777762292, 0.239598554061257, 0.0986979012610507, 0.363786969611213, 0.0907941719789316, -0.551599533260813, -0.617800855762348, -0.991389847235408, -0.311169353699879, 1.46817697209427, -0.470400525259478, 0.207971241929242, 0.0257905801985591, 0.403992960255733, 0.251412098239705, -0.018306777944153, 0.277837575558899, -0.110473910188767, 0.0669280749146731, 0.128539358273528, -0.189114843888824, 0.133558376740387, -0.0210530534538215, 149.62] features.shape: (284807, 30) targets.shape: (284807, 1) Prepare a validation set num_val_samples = int(len(features) * 0.2) train_features = features[:-num_val_samples] train_targets = targets[:-num_val_samples] val_features = features[-num_val_samples:] val_targets = targets[-num_val_samples:] print(\"Number of training samples:\", len(train_features)) print(\"Number of validation samples:\", len(val_features)) Number of training samples: 227846 Number of validation samples: 56961 Analyze class imbalance in the targets counts = np.bincount(train_targets[:, 0]) print( \"Number of positive samples in training data: {} ({:.2f}% of total)\".format( counts[1], 100 * float(counts[1]) / len(train_targets) ) ) weight_for_0 = 1.0 / counts[0] weight_for_1 = 1.0 / counts[1] Number of positive samples in training data: 417 (0.18% of total) Normalize the data using training set statistics mean = np.mean(train_features, axis=0) train_features -= mean val_features -= mean std = np.std(train_features, axis=0) train_features /= std val_features /= std Build a binary classification model from tensorflow import keras model = keras.Sequential( [ keras.layers.Dense( 256, activation=\"relu\", input_shape=(train_features.shape[-1],) ), keras.layers.Dense(256, activation=\"relu\"), keras.layers.Dropout(0.3), keras.layers.Dense(256, activation=\"relu\"), keras.layers.Dropout(0.3), keras.layers.Dense(1, activation=\"sigmoid\"), ] ) model.summary() Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense (Dense) (None, 256) 7936 _________________________________________________________________ dense_1 (Dense) (None, 256) 65792 _________________________________________________________________ dropout (Dropout) (None, 256) 0 _________________________________________________________________ dense_2 (Dense) (None, 256) 65792 _________________________________________________________________ dropout_1 (Dropout) (None, 256) 0 _________________________________________________________________ dense_3 (Dense) (None, 1) 257 ================================================================= Total params: 139,777 Trainable params: 139,777 Non-trainable params: 0 _________________________________________________________________ Train the model with class_weight argument metrics = [ keras.metrics.FalseNegatives(name=\"fn\"), keras.metrics.FalsePositives(name=\"fp\"), keras.metrics.TrueNegatives(name=\"tn\"), keras.metrics.TruePositives(name=\"tp\"), keras.metrics.Precision(name=\"precision\"), keras.metrics.Recall(name=\"recall\"), ] model.compile( optimizer=keras.optimizers.Adam(1e-2), loss=\"binary_crossentropy\", metrics=metrics ) callbacks = [keras.callbacks.ModelCheckpoint(\"fraud_model_at_epoch_{epoch}.h5\")] class_weight = {0: weight_for_0, 1: weight_for_1} model.fit( train_features, train_targets, batch_size=2048, epochs=30, verbose=2, callbacks=callbacks, validation_data=(val_features, val_targets), class_weight=class_weight, ) Epoch 1/30 112/112 - 2s - loss: 2.4210e-06 - fn: 51.0000 - fp: 29417.0000 - tn: 198012.0000 - tp: 366.0000 - precision: 0.0123 - recall: 0.8777 - val_loss: 0.0759 - val_fn: 9.0000 - val_fp: 611.0000 - val_tn: 56275.0000 - val_tp: 66.0000 - val_precision: 0.0975 - val_recall: 0.8800 Epoch 2/30 112/112 - 2s - loss: 1.4337e-06 - fn: 35.0000 - fp: 7058.0000 - tn: 220371.0000 - tp: 382.0000 - precision: 0.0513 - recall: 0.9161 - val_loss: 0.1632 - val_fn: 6.0000 - val_fp: 2343.0000 - val_tn: 54543.0000 - val_tp: 69.0000 - val_precision: 0.0286 - val_recall: 0.9200 Epoch 3/30 112/112 - 2s - loss: 1.2100e-06 - fn: 27.0000 - fp: 7382.0000 - tn: 220047.0000 - tp: 390.0000 - precision: 0.0502 - recall: 0.9353 - val_loss: 0.1882 - val_fn: 5.0000 - val_fp: 3690.0000 - val_tn: 53196.0000 - val_tp: 70.0000 - val_precision: 0.0186 - val_recall: 0.9333 Epoch 4/30 112/112 - 2s - loss: 1.0770e-06 - fn: 24.0000 - fp: 7306.0000 - tn: 220123.0000 - tp: 393.0000 - precision: 0.0510 - recall: 0.9424 - val_loss: 0.0444 - val_fn: 9.0000 - val_fp: 674.0000 - val_tn: 56212.0000 - val_tp: 66.0000 - val_precision: 0.0892 - val_recall: 0.8800 Epoch 5/30 112/112 - 2s - loss: 9.3284e-07 - fn: 18.0000 - fp: 5607.0000 - tn: 221822.0000 - tp: 399.0000 - precision: 0.0664 - recall: 0.9568 - val_loss: 0.0455 - val_fn: 8.0000 - val_fp: 604.0000 - val_tn: 56282.0000 - val_tp: 67.0000 - val_precision: 0.0999 - val_recall: 0.8933 Epoch 6/30 112/112 - 2s - loss: 8.9186e-07 - fn: 21.0000 - fp: 6917.0000 - tn: 220512.0000 - tp: 396.0000 - precision: 0.0542 - recall: 0.9496 - val_loss: 0.0385 - val_fn: 9.0000 - val_fp: 462.0000 - val_tn: 56424.0000 - val_tp: 66.0000 - val_precision: 0.1250 - val_recall: 0.8800 Epoch 7/30 112/112 - 2s - loss: 6.4562e-07 - fn: 13.0000 - fp: 5878.0000 - tn: 221551.0000 - tp: 404.0000 - precision: 0.0643 - recall: 0.9688 - val_loss: 0.0205 - val_fn: 9.0000 - val_fp: 372.0000 - val_tn: 56514.0000 - val_tp: 66.0000 - val_precision: 0.1507 - val_recall: 0.8800 Epoch 8/30 112/112 - 2s - loss: 7.3378e-07 - fn: 15.0000 - fp: 6825.0000 - tn: 220604.0000 - tp: 402.0000 - precision: 0.0556 - recall: 0.9640 - val_loss: 0.0188 - val_fn: 10.0000 - val_fp: 246.0000 - val_tn: 56640.0000 - val_tp: 65.0000 - val_precision: 0.2090 - val_recall: 0.8667 Epoch 9/30 112/112 - 2s - loss: 5.1385e-07 - fn: 9.0000 - fp: 5265.0000 - tn: 222164.0000 - tp: 408.0000 - precision: 0.0719 - recall: 0.9784 - val_loss: 0.0244 - val_fn: 11.0000 - val_fp: 495.0000 - val_tn: 56391.0000 - val_tp: 64.0000 - val_precision: 0.1145 - val_recall: 0.8533 Epoch 10/30 112/112 - 2s - loss: 8.6498e-07 - fn: 13.0000 - fp: 8506.0000 - tn: 218923.0000 - tp: 404.0000 - precision: 0.0453 - recall: 0.9688 - val_loss: 0.0177 - val_fn: 11.0000 - val_fp: 367.0000 - val_tn: 56519.0000 - val_tp: 64.0000 - val_precision: 0.1485 - val_recall: 0.8533 Epoch 11/30 112/112 - 2s - loss: 6.0585e-07 - fn: 12.0000 - fp: 6676.0000 - tn: 220753.0000 - tp: 405.0000 - precision: 0.0572 - recall: 0.9712 - val_loss: 0.0356 - val_fn: 9.0000 - val_fp: 751.0000 - val_tn: 56135.0000 - val_tp: 66.0000 - val_precision: 0.0808 - val_recall: 0.8800 Epoch 12/30 112/112 - 2s - loss: 6.0788e-07 - fn: 9.0000 - fp: 6219.0000 - tn: 221210.0000 - tp: 408.0000 - precision: 0.0616 - recall: 0.9784 - val_loss: 0.0249 - val_fn: 10.0000 - val_fp: 487.0000 - val_tn: 56399.0000 - val_tp: 65.0000 - val_precision: 0.1178 - val_recall: 0.8667 Epoch 13/30 112/112 - 3s - loss: 8.3899e-07 - fn: 12.0000 - fp: 6612.0000 - tn: 220817.0000 - tp: 405.0000 - precision: 0.0577 - recall: 0.9712 - val_loss: 0.0905 - val_fn: 5.0000 - val_fp: 2159.0000 - val_tn: 54727.0000 - val_tp: 70.0000 - val_precision: 0.0314 - val_recall: 0.9333 Epoch 14/30 112/112 - 3s - loss: 6.0584e-07 - fn: 8.0000 - fp: 6823.0000 - tn: 220606.0000 - tp: 409.0000 - precision: 0.0566 - recall: 0.9808 - val_loss: 0.0205 - val_fn: 10.0000 - val_fp: 446.0000 - val_tn: 56440.0000 - val_tp: 65.0000 - val_precision: 0.1272 - val_recall: 0.8667 Epoch 15/30 112/112 - 2s - loss: 3.9569e-07 - fn: 6.0000 - fp: 3820.0000 - tn: 223609.0000 - tp: 411.0000 - precision: 0.0971 - recall: 0.9856 - val_loss: 0.0212 - val_fn: 10.0000 - val_fp: 413.0000 - val_tn: 56473.0000 - val_tp: 65.0000 - val_precision: 0.1360 - val_recall: 0.8667 Epoch 16/30 112/112 - 2s - loss: 5.4548e-07 - fn: 5.0000 - fp: 3910.0000 - tn: 223519.0000 - tp: 412.0000 - precision: 0.0953 - recall: 0.9880 - val_loss: 0.0906 - val_fn: 8.0000 - val_fp: 1905.0000 - val_tn: 54981.0000 - val_tp: 67.0000 - val_precision: 0.0340 - val_recall: 0.8933 Epoch 17/30 112/112 - 3s - loss: 6.2734e-07 - fn: 8.0000 - fp: 6005.0000 - tn: 221424.0000 - tp: 409.0000 - precision: 0.0638 - recall: 0.9808 - val_loss: 0.0161 - val_fn: 10.0000 - val_fp: 340.0000 - val_tn: 56546.0000 - val_tp: 65.0000 - val_precision: 0.1605 - val_recall: 0.8667 Epoch 18/30 112/112 - 3s - loss: 4.9752e-07 - fn: 5.0000 - fp: 4302.0000 - tn: 223127.0000 - tp: 412.0000 - precision: 0.0874 - recall: 0.9880 - val_loss: 0.0186 - val_fn: 10.0000 - val_fp: 408.0000 - val_tn: 56478.0000 - val_tp: 65.0000 - val_precision: 0.1374 - val_recall: 0.8667 Epoch 19/30 112/112 - 3s - loss: 6.7296e-07 - fn: 5.0000 - fp: 5986.0000 - tn: 221443.0000 - tp: 412.0000 - precision: 0.0644 - recall: 0.9880 - val_loss: 0.0165 - val_fn: 10.0000 - val_fp: 276.0000 - val_tn: 56610.0000 - val_tp: 65.0000 - val_precision: 0.1906 - val_recall: 0.8667 Epoch 20/30 112/112 - 3s - loss: 5.0178e-07 - fn: 7.0000 - fp: 5161.0000 - tn: 222268.0000 - tp: 410.0000 - precision: 0.0736 - recall: 0.9832 - val_loss: 0.2156 - val_fn: 7.0000 - val_fp: 1041.0000 - val_tn: 55845.0000 - val_tp: 68.0000 - val_precision: 0.0613 - val_recall: 0.9067 Epoch 21/30 112/112 - 3s - loss: 7.1907e-07 - fn: 7.0000 - fp: 5825.0000 - tn: 221604.0000 - tp: 410.0000 - precision: 0.0658 - recall: 0.9832 - val_loss: 0.0283 - val_fn: 8.0000 - val_fp: 511.0000 - val_tn: 56375.0000 - val_tp: 67.0000 - val_precision: 0.1159 - val_recall: 0.8933 Epoch 22/30 112/112 - 3s - loss: 3.6405e-07 - fn: 6.0000 - fp: 4149.0000 - tn: 223280.0000 - tp: 411.0000 - precision: 0.0901 - recall: 0.9856 - val_loss: 0.0269 - val_fn: 8.0000 - val_fp: 554.0000 - val_tn: 56332.0000 - val_tp: 67.0000 - val_precision: 0.1079 - val_recall: 0.8933 Epoch 23/30 112/112 - 3s - loss: 2.8464e-07 - fn: 1.0000 - fp: 4131.0000 - tn: 223298.0000 - tp: 416.0000 - precision: 0.0915 - recall: 0.9976 - val_loss: 0.0097 - val_fn: 10.0000 - val_fp: 191.0000 - val_tn: 56695.0000 - val_tp: 65.0000 - val_precision: 0.2539 - val_recall: 0.8667 Epoch 24/30 112/112 - 3s - loss: 3.2445e-07 - fn: 3.0000 - fp: 4040.0000 - tn: 223389.0000 - tp: 414.0000 - precision: 0.0930 - recall: 0.9928 - val_loss: 0.0129 - val_fn: 9.0000 - val_fp: 278.0000 - val_tn: 56608.0000 - val_tp: 66.0000 - val_precision: 0.1919 - val_recall: 0.8800 Epoch 25/30 112/112 - 3s - loss: 5.4032e-07 - fn: 4.0000 - fp: 4834.0000 - tn: 222595.0000 - tp: 413.0000 - precision: 0.0787 - recall: 0.9904 - val_loss: 0.1334 - val_fn: 7.0000 - val_fp: 885.0000 - val_tn: 56001.0000 - val_tp: 68.0000 - val_precision: 0.0714 - val_recall: 0.9067 Epoch 26/30 112/112 - 3s - loss: 1.2099e-06 - fn: 9.0000 - fp: 5767.0000 - tn: 221662.0000 - tp: 408.0000 - precision: 0.0661 - recall: 0.9784 - val_loss: 0.0426 - val_fn: 11.0000 - val_fp: 211.0000 - val_tn: 56675.0000 - val_tp: 64.0000 - val_precision: 0.2327 - val_recall: 0.8533 Epoch 27/30 112/112 - 2s - loss: 5.0924e-07 - fn: 7.0000 - fp: 4185.0000 - tn: 223244.0000 - tp: 410.0000 - precision: 0.0892 - recall: 0.9832 - val_loss: 0.0345 - val_fn: 6.0000 - val_fp: 710.0000 - val_tn: 56176.0000 - val_tp: 69.0000 - val_precision: 0.0886 - val_recall: 0.9200 Epoch 28/30 112/112 - 3s - loss: 4.9177e-07 - fn: 7.0000 - fp: 3871.0000 - tn: 223558.0000 - tp: 410.0000 - precision: 0.0958 - recall: 0.9832 - val_loss: 0.0631 - val_fn: 7.0000 - val_fp: 912.0000 - val_tn: 55974.0000 - val_tp: 68.0000 - val_precision: 0.0694 - val_recall: 0.9067 Epoch 29/30 112/112 - 3s - loss: 1.8390e-06 - fn: 9.0000 - fp: 7199.0000 - tn: 220230.0000 - tp: 408.0000 - precision: 0.0536 - recall: 0.9784 - val_loss: 0.0661 - val_fn: 10.0000 - val_fp: 292.0000 - val_tn: 56594.0000 - val_tp: 65.0000 - val_precision: 0.1821 - val_recall: 0.8667 Epoch 30/30 112/112 - 3s - loss: 3.5976e-06 - fn: 14.0000 - fp: 5541.0000 - tn: 221888.0000 - tp: 403.0000 - precision: 0.0678 - recall: 0.9664 - val_loss: 0.1205 - val_fn: 10.0000 - val_fp: 206.0000 - val_tn: 56680.0000 - val_tp: 65.0000 - val_precision: 0.2399 - val_recall: 0.8667 Conclusions At the end of training, out of 56,961 validation transactions, we are: Correctly identifying 66 of them as fraudulent Missing 9 fraudulent transactions At the cost of incorrectly flagging 441 legitimate transactions In the real world, one would put an even higher weight on class 1, so as to reflect that False Negatives are more costly than False Positives. Next time your credit card gets declined in an online purchase -- this is why. Binary classification of structured data including numerical and categorical features. Introduction This example demonstrates how to do structured data classification, starting from a raw CSV file. Our data includes both numerical and categorical features. We will use Keras preprocessing layers to normalize the numerical features and vectorize the categorical ones. Note that this example should be run with TensorFlow 2.5 or higher. The dataset Our dataset is provided by the Cleveland Clinic Foundation for Heart Disease. It's a CSV file with 303 rows. Each row contains information about a patient (a sample), and each column describes an attribute of the patient (a feature). We use the features to predict whether a patient has a heart disease (binary classification). Here's the description of each feature: Column Description Feature Type Age Age in years Numerical Sex (1 = male; 0 = female) Categorical CP Chest pain type (0, 1, 2, 3, 4) Categorical Trestbpd Resting blood pressure (in mm Hg on admission) Numerical Chol Serum cholesterol in mg/dl Numerical FBS fasting blood sugar in 120 mg/dl (1 = true; 0 = false) Categorical RestECG Resting electrocardiogram results (0, 1, 2) Categorical Thalach Maximum heart rate achieved Numerical Exang Exercise induced angina (1 = yes; 0 = no) Categorical Oldpeak ST depression induced by exercise relative to rest Numerical Slope Slope of the peak exercise ST segment Numerical CA Number of major vessels (0-3) colored by fluoroscopy Both numerical & categorical Thal 3 = normal; 6 = fixed defect; 7 = reversible defect Categorical Target Diagnosis of heart disease (1 = true; 0 = false) Target Setup import tensorflow as tf import numpy as np import pandas as pd from tensorflow import keras from tensorflow.keras import layers Preparing the data Let's download the data and load it into a Pandas dataframe: file_url = \"http://storage.googleapis.com/download.tensorflow.org/data/heart.csv\" dataframe = pd.read_csv(file_url) The dataset includes 303 samples with 14 columns per sample (13 features, plus the target label): dataframe.shape (303, 14) Here's a preview of a few samples: dataframe.head() age sex cp trestbps chol fbs restecg thalach exang oldpeak slope ca thal target 0 63 1 1 145 233 1 2 150 0 2.3 3 0 fixed 0 1 67 1 4 160 286 0 2 108 1 1.5 2 3 normal 1 2 67 1 4 120 229 0 2 129 1 2.6 2 2 reversible 0 3 37 1 3 130 250 0 0 187 0 3.5 3 0 normal 0 4 41 0 2 130 204 0 2 172 0 1.4 1 0 normal 0 The last column, \"target\", indicates whether the patient has a heart disease (1) or not (0). Let's split the data into a training and validation set: val_dataframe = dataframe.sample(frac=0.2, random_state=1337) train_dataframe = dataframe.drop(val_dataframe.index) print( \"Using %d samples for training and %d for validation\" % (len(train_dataframe), len(val_dataframe)) ) Using 242 samples for training and 61 for validation Let's generate tf.data.Dataset objects for each dataframe: def dataframe_to_dataset(dataframe): dataframe = dataframe.copy() labels = dataframe.pop(\"target\") ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels)) ds = ds.shuffle(buffer_size=len(dataframe)) return ds train_ds = dataframe_to_dataset(train_dataframe) val_ds = dataframe_to_dataset(val_dataframe) Each Dataset yields a tuple (input, target) where input is a dictionary of features and target is the value 0 or 1: for x, y in train_ds.take(1): print(\"Input:\", x) print(\"Target:\", y) Input: {'age': , 'sex': , 'cp': , 'trestbps': , 'chol': , 'fbs': , 'restecg': , 'thalach': , 'exang': , 'oldpeak': , 'slope': , 'ca': , 'thal': } Target: tf.Tensor(1, shape=(), dtype=int64) Let's batch the datasets: train_ds = train_ds.batch(32) val_ds = val_ds.batch(32) Feature preprocessing with Keras layers The following features are categorical features encoded as integers: sex cp fbs restecg exang ca We will encode these features using one-hot encoding. We have two options here: Use CategoryEncoding(), which requires knowing the range of input values and will error on input outside the range. Use IntegerLookup() which will build a lookup table for inputs and reserve an output index for unkown input values. For this example, we want a simple solution that will handle out of range inputs at inference, so we will use IntegerLookup(). We also have a categorical feature encoded as a string: thal. We will create an index of all possible features and encode output using the StringLookup() layer. Finally, the following feature are continuous numerical features: age trestbps chol thalach oldpeak slope For each of these features, we will use a Normalization() layer to make sure the mean of each feature is 0 and its standard deviation is 1. Below, we define 3 utility functions to do the operations: encode_numerical_feature to apply featurewise normalization to numerical features. encode_string_categorical_feature to first turn string inputs into integer indices, then one-hot encode these integer indices. encode_integer_categorical_feature to one-hot encode integer categorical features. from tensorflow.keras.layers import IntegerLookup from tensorflow.keras.layers import Normalization from tensorflow.keras.layers import StringLookup def encode_numerical_feature(feature, name, dataset): # Create a Normalization layer for our feature normalizer = Normalization() # Prepare a Dataset that only yields our feature feature_ds = dataset.map(lambda x, y: x[name]) feature_ds = feature_ds.map(lambda x: tf.expand_dims(x, -1)) # Learn the statistics of the data normalizer.adapt(feature_ds) # Normalize the input feature encoded_feature = normalizer(feature) return encoded_feature def encode_categorical_feature(feature, name, dataset, is_string): lookup_class = StringLookup if is_string else IntegerLookup # Create a lookup layer which will turn strings into integer indices lookup = lookup_class(output_mode=\"binary\") # Prepare a Dataset that only yields our feature feature_ds = dataset.map(lambda x, y: x[name]) feature_ds = feature_ds.map(lambda x: tf.expand_dims(x, -1)) # Learn the set of possible string values and assign them a fixed integer index lookup.adapt(feature_ds) # Turn the string input into integer indices encoded_feature = lookup(feature) return encoded_feature Build a model With this done, we can create our end-to-end model: # Categorical features encoded as integers sex = keras.Input(shape=(1,), name=\"sex\", dtype=\"int64\") cp = keras.Input(shape=(1,), name=\"cp\", dtype=\"int64\") fbs = keras.Input(shape=(1,), name=\"fbs\", dtype=\"int64\") restecg = keras.Input(shape=(1,), name=\"restecg\", dtype=\"int64\") exang = keras.Input(shape=(1,), name=\"exang\", dtype=\"int64\") ca = keras.Input(shape=(1,), name=\"ca\", dtype=\"int64\") # Categorical feature encoded as string thal = keras.Input(shape=(1,), name=\"thal\", dtype=\"string\") # Numerical features age = keras.Input(shape=(1,), name=\"age\") trestbps = keras.Input(shape=(1,), name=\"trestbps\") chol = keras.Input(shape=(1,), name=\"chol\") thalach = keras.Input(shape=(1,), name=\"thalach\") oldpeak = keras.Input(shape=(1,), name=\"oldpeak\") slope = keras.Input(shape=(1,), name=\"slope\") all_inputs = [ sex, cp, fbs, restecg, exang, ca, thal, age, trestbps, chol, thalach, oldpeak, slope, ] # Integer categorical features sex_encoded = encode_categorical_feature(sex, \"sex\", train_ds, False) cp_encoded = encode_categorical_feature(cp, \"cp\", train_ds, False) fbs_encoded = encode_categorical_feature(fbs, \"fbs\", train_ds, False) restecg_encoded = encode_categorical_feature(restecg, \"restecg\", train_ds, False) exang_encoded = encode_categorical_feature(exang, \"exang\", train_ds, False) ca_encoded = encode_categorical_feature(ca, \"ca\", train_ds, False) # String categorical features thal_encoded = encode_categorical_feature(thal, \"thal\", train_ds, True) # Numerical features age_encoded = encode_numerical_feature(age, \"age\", train_ds) trestbps_encoded = encode_numerical_feature(trestbps, \"trestbps\", train_ds) chol_encoded = encode_numerical_feature(chol, \"chol\", train_ds) thalach_encoded = encode_numerical_feature(thalach, \"thalach\", train_ds) oldpeak_encoded = encode_numerical_feature(oldpeak, \"oldpeak\", train_ds) slope_encoded = encode_numerical_feature(slope, \"slope\", train_ds) all_features = layers.concatenate( [ sex_encoded, cp_encoded, fbs_encoded, restecg_encoded, exang_encoded, slope_encoded, ca_encoded, thal_encoded, age_encoded, trestbps_encoded, chol_encoded, thalach_encoded, oldpeak_encoded, ] ) x = layers.Dense(32, activation=\"relu\")(all_features) x = layers.Dropout(0.5)(x) output = layers.Dense(1, activation=\"sigmoid\")(x) model = keras.Model(all_inputs, output) model.compile(\"adam\", \"binary_crossentropy\", metrics=[\"accuracy\"]) Let's visualize our connectivity graph: # `rankdir='LR'` is to make the graph horizontal. keras.utils.plot_model(model, show_shapes=True, rankdir=\"LR\") ('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.') Train the model model.fit(train_ds, epochs=50, validation_data=val_ds) Epoch 1/50 8/8 [==============================] - 1s 35ms/step - loss: 0.7554 - accuracy: 0.5058 - val_loss: 0.6907 - val_accuracy: 0.6393 Epoch 2/50 8/8 [==============================] - 0s 4ms/step - loss: 0.7024 - accuracy: 0.5917 - val_loss: 0.6564 - val_accuracy: 0.7049 Epoch 3/50 8/8 [==============================] - 0s 5ms/step - loss: 0.6661 - accuracy: 0.6249 - val_loss: 0.6252 - val_accuracy: 0.7213 Epoch 4/50 8/8 [==============================] - 0s 4ms/step - loss: 0.6287 - accuracy: 0.7024 - val_loss: 0.5978 - val_accuracy: 0.7377 Epoch 5/50 8/8 [==============================] - 0s 4ms/step - loss: 0.6490 - accuracy: 0.6668 - val_loss: 0.5745 - val_accuracy: 0.7213 Epoch 6/50 8/8 [==============================] - 0s 4ms/step - loss: 0.5906 - accuracy: 0.7570 - val_loss: 0.5550 - val_accuracy: 0.7541 Epoch 7/50 8/8 [==============================] - 0s 4ms/step - loss: 0.5659 - accuracy: 0.7353 - val_loss: 0.5376 - val_accuracy: 0.7869 Epoch 8/50 8/8 [==============================] - 0s 4ms/step - loss: 0.5463 - accuracy: 0.7190 - val_loss: 0.5219 - val_accuracy: 0.7869 Epoch 9/50 8/8 [==============================] - 0s 3ms/step - loss: 0.5498 - accuracy: 0.7106 - val_loss: 0.5082 - val_accuracy: 0.7869 Epoch 10/50 8/8 [==============================] - 0s 4ms/step - loss: 0.5344 - accuracy: 0.7141 - val_loss: 0.4965 - val_accuracy: 0.8033 Epoch 11/50 8/8 [==============================] - 0s 4ms/step - loss: 0.5369 - accuracy: 0.6961 - val_loss: 0.4857 - val_accuracy: 0.8033 Epoch 12/50 8/8 [==============================] - 0s 5ms/step - loss: 0.4920 - accuracy: 0.7948 - val_loss: 0.4757 - val_accuracy: 0.8197 Epoch 13/50 8/8 [==============================] - 0s 4ms/step - loss: 0.4802 - accuracy: 0.7915 - val_loss: 0.4674 - val_accuracy: 0.8197 Epoch 14/50 8/8 [==============================] - 0s 3ms/step - loss: 0.4936 - accuracy: 0.7382 - val_loss: 0.4599 - val_accuracy: 0.8197 Epoch 15/50 8/8 [==============================] - 0s 4ms/step - loss: 0.4956 - accuracy: 0.7907 - val_loss: 0.4538 - val_accuracy: 0.8033 Epoch 16/50 8/8 [==============================] - 0s 5ms/step - loss: 0.4455 - accuracy: 0.7839 - val_loss: 0.4484 - val_accuracy: 0.8033 Epoch 17/50 8/8 [==============================] - 0s 3ms/step - loss: 0.4192 - accuracy: 0.8480 - val_loss: 0.4432 - val_accuracy: 0.8197 Epoch 18/50 8/8 [==============================] - 0s 3ms/step - loss: 0.4265 - accuracy: 0.7966 - val_loss: 0.4393 - val_accuracy: 0.8197 Epoch 19/50 8/8 [==============================] - 0s 3ms/step - loss: 0.4694 - accuracy: 0.8085 - val_loss: 0.4366 - val_accuracy: 0.8197 Epoch 20/50 8/8 [==============================] - 0s 4ms/step - loss: 0.4566 - accuracy: 0.8133 - val_loss: 0.4336 - val_accuracy: 0.8197 Epoch 21/50 8/8 [==============================] - 0s 4ms/step - loss: 0.4060 - accuracy: 0.8351 - val_loss: 0.4314 - val_accuracy: 0.8197 Epoch 22/50 8/8 [==============================] - 0s 4ms/step - loss: 0.4059 - accuracy: 0.8435 - val_loss: 0.4290 - val_accuracy: 0.8197 Epoch 23/50 8/8 [==============================] - 0s 5ms/step - loss: 0.3863 - accuracy: 0.8342 - val_loss: 0.4272 - val_accuracy: 0.8197 Epoch 24/50 8/8 [==============================] - 0s 5ms/step - loss: 0.4222 - accuracy: 0.7998 - val_loss: 0.4260 - val_accuracy: 0.8197 Epoch 25/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3662 - accuracy: 0.8245 - val_loss: 0.4247 - val_accuracy: 0.8033 Epoch 26/50 8/8 [==============================] - 0s 5ms/step - loss: 0.4014 - accuracy: 0.8217 - val_loss: 0.4232 - val_accuracy: 0.8033 Epoch 27/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3935 - accuracy: 0.8375 - val_loss: 0.4219 - val_accuracy: 0.8033 Epoch 28/50 8/8 [==============================] - 0s 4ms/step - loss: 0.4319 - accuracy: 0.8026 - val_loss: 0.4206 - val_accuracy: 0.8197 Epoch 29/50 8/8 [==============================] - 0s 5ms/step - loss: 0.3893 - accuracy: 0.8074 - val_loss: 0.4202 - val_accuracy: 0.8197 Epoch 30/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3437 - accuracy: 0.8605 - val_loss: 0.4200 - val_accuracy: 0.8197 Epoch 31/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3859 - accuracy: 0.8133 - val_loss: 0.4198 - val_accuracy: 0.8197 Epoch 32/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3716 - accuracy: 0.8443 - val_loss: 0.4195 - val_accuracy: 0.8197 Epoch 33/50 8/8 [==============================] - 0s 5ms/step - loss: 0.3691 - accuracy: 0.8217 - val_loss: 0.4198 - val_accuracy: 0.8197 Epoch 34/50 8/8 [==============================] - 0s 5ms/step - loss: 0.3579 - accuracy: 0.8388 - val_loss: 0.4195 - val_accuracy: 0.8197 Epoch 35/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3164 - accuracy: 0.8620 - val_loss: 0.4199 - val_accuracy: 0.8197 Epoch 36/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3276 - accuracy: 0.8433 - val_loss: 0.4210 - val_accuracy: 0.8197 Epoch 37/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3781 - accuracy: 0.8469 - val_loss: 0.4214 - val_accuracy: 0.8197 Epoch 38/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3522 - accuracy: 0.8482 - val_loss: 0.4214 - val_accuracy: 0.8197 Epoch 39/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3988 - accuracy: 0.7981 - val_loss: 0.4216 - val_accuracy: 0.8197 Epoch 40/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3340 - accuracy: 0.8782 - val_loss: 0.4229 - val_accuracy: 0.8197 Epoch 41/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3404 - accuracy: 0.8318 - val_loss: 0.4227 - val_accuracy: 0.8197 Epoch 42/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3005 - accuracy: 0.8533 - val_loss: 0.4225 - val_accuracy: 0.8197 Epoch 43/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3364 - accuracy: 0.8675 - val_loss: 0.4223 - val_accuracy: 0.8197 Epoch 44/50 8/8 [==============================] - 0s 4ms/step - loss: 0.2801 - accuracy: 0.8792 - val_loss: 0.4229 - val_accuracy: 0.8197 Epoch 45/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3463 - accuracy: 0.8487 - val_loss: 0.4237 - val_accuracy: 0.8197 Epoch 46/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3047 - accuracy: 0.8694 - val_loss: 0.4238 - val_accuracy: 0.8197 Epoch 47/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3157 - accuracy: 0.8621 - val_loss: 0.4249 - val_accuracy: 0.8197 Epoch 48/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3048 - accuracy: 0.8557 - val_loss: 0.4251 - val_accuracy: 0.8197 Epoch 49/50 8/8 [==============================] - 0s 4ms/step - loss: 0.3722 - accuracy: 0.8316 - val_loss: 0.4254 - val_accuracy: 0.8197 Epoch 50/50 8/8 [==============================] - 0s 5ms/step - loss: 0.3302 - accuracy: 0.8688 - val_loss: 0.4254 - val_accuracy: 0.8197 We quickly get to 80% validation accuracy. Inference on new data To get a prediction for a new sample, you can simply call model.predict(). There are just two things you need to do: wrap scalars into a list so as to have a batch dimension (models only process batches of data, not single samples) Call convert_to_tensor on each feature sample = { \"age\": 60, \"sex\": 1, \"cp\": 1, \"trestbps\": 145, \"chol\": 233, \"fbs\": 1, \"restecg\": 2, \"thalach\": 150, \"exang\": 0, \"oldpeak\": 2.3, \"slope\": 3, \"ca\": 0, \"thal\": \"fixed\", } input_dict = {name: tf.convert_to_tensor([value]) for name, value in sample.items()} predictions = model.predict(input_dict) print( \"This particular patient had a %.1f percent probability \" \"of having a heart disease, as evaluated by our model.\" % (100 * predictions[0][0],) ) This particular patient had a 18.8 percent probability of having a heart disease, as evaluated by our model. Using Wide & Deep and Deep & Cross networks for structured data classification. Introduction This example demonstrates how to do structured data classification using the two modeling techniques: Wide & Deep models Deep & Cross models Note that this example should be run with TensorFlow 2.5 or higher. The dataset This example uses the Covertype dataset from the UCI Machine Learning Repository. The task is to predict forest cover type from cartographic variables. The dataset includes 506,011 instances with 12 input features: 10 numerical features and 2 categorical features. Each instance is categorized into 1 of 7 classes. Setup import math import numpy as np import pandas as pd import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers Prepare the data First, let's load the dataset from the UCI Machine Learning Repository into a Pandas DataFrame: data_url = ( \"https://archive.ics.uci.edu/ml/machine-learning-databases/covtype/covtype.data.gz\" ) raw_data = pd.read_csv(data_url, header=None) print(f\"Dataset shape: {raw_data.shape}\") raw_data.head() Dataset shape: (581012, 55) 0 1 2 3 4 5 6 7 8 9 ... 45 46 47 48 49 50 51 52 53 54 0 2596 51 3 258 0 510 221 232 148 6279 ... 0 0 0 0 0 0 0 0 0 5 1 2590 56 2 212 -6 390 220 235 151 6225 ... 0 0 0 0 0 0 0 0 0 5 2 2804 139 9 268 65 3180 234 238 135 6121 ... 0 0 0 0 0 0 0 0 0 2 3 2785 155 18 242 118 3090 238 238 122 6211 ... 0 0 0 0 0 0 0 0 0 2 4 2595 45 2 153 -1 391 220 234 150 6172 ... 0 0 0 0 0 0 0 0 0 5 5 rows × 55 columns The two categorical features in the dataset are binary-encoded. We will convert this dataset representation to the typical representation, where each categorical feature is represented as a single integer value. soil_type_values = [f\"soil_type_{idx+1}\" for idx in range(40)] wilderness_area_values = [f\"area_type_{idx+1}\" for idx in range(4)] soil_type = raw_data.loc[:, 14:53].apply( lambda x: soil_type_values[0::1][x.to_numpy().nonzero()[0][0]], axis=1 ) wilderness_area = raw_data.loc[:, 10:13].apply( lambda x: wilderness_area_values[0::1][x.to_numpy().nonzero()[0][0]], axis=1 ) CSV_HEADER = [ \"Elevation\", \"Aspect\", \"Slope\", \"Horizontal_Distance_To_Hydrology\", \"Vertical_Distance_To_Hydrology\", \"Horizontal_Distance_To_Roadways\", \"Hillshade_9am\", \"Hillshade_Noon\", \"Hillshade_3pm\", \"Horizontal_Distance_To_Fire_Points\", \"Wilderness_Area\", \"Soil_Type\", \"Cover_Type\", ] data = pd.concat( [raw_data.loc[:, 0:9], wilderness_area, soil_type, raw_data.loc[:, 54]], axis=1, ignore_index=True, ) data.columns = CSV_HEADER # Convert the target label indices into a range from 0 to 6 (there are 7 labels in total). data[\"Cover_Type\"] = data[\"Cover_Type\"] - 1 print(f\"Dataset shape: {data.shape}\") data.head().T Dataset shape: (581012, 13) 0 1 2 3 4 Elevation 2596 2590 2804 2785 2595 Aspect 51 56 139 155 45 Slope 3 2 9 18 2 Horizontal_Distance_To_Hydrology 258 212 268 242 153 Vertical_Distance_To_Hydrology 0 -6 65 118 -1 Horizontal_Distance_To_Roadways 510 390 3180 3090 391 Hillshade_9am 221 220 234 238 220 Hillshade_Noon 232 235 238 238 234 Hillshade_3pm 148 151 135 122 150 Horizontal_Distance_To_Fire_Points 6279 6225 6121 6211 6172 Wilderness_Area area_type_1 area_type_1 area_type_1 area_type_1 area_type_1 Soil_Type soil_type_29 soil_type_29 soil_type_12 soil_type_30 soil_type_29 Cover_Type 4 4 1 1 4 The shape of the DataFrame shows there are 13 columns per sample (12 for the features and 1 for the target label). Let's split the data into training (85%) and test (15%) sets. train_splits = [] test_splits = [] for _, group_data in data.groupby(\"Cover_Type\"): random_selection = np.random.rand(len(group_data.index)) <= 0.85 train_splits.append(group_data[random_selection]) test_splits.append(group_data[~random_selection]) train_data = pd.concat(train_splits).sample(frac=1).reset_index(drop=True) test_data = pd.concat(test_splits).sample(frac=1).reset_index(drop=True) print(f\"Train split size: {len(train_data.index)}\") print(f\"Test split size: {len(test_data.index)}\") Train split size: 493323 Test split size: 87689 Next, store the training and test data in separate CSV files. train_data_file = \"train_data.csv\" test_data_file = \"test_data.csv\" train_data.to_csv(train_data_file, index=False) test_data.to_csv(test_data_file, index=False) Define dataset metadata Here, we define the metadata of the dataset that will be useful for reading and parsing the data into input features, and encoding the input features with respect to their types. TARGET_FEATURE_NAME = \"Cover_Type\" TARGET_FEATURE_LABELS = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\"] NUMERIC_FEATURE_NAMES = [ \"Aspect\", \"Elevation\", \"Hillshade_3pm\", \"Hillshade_9am\", \"Hillshade_Noon\", \"Horizontal_Distance_To_Fire_Points\", \"Horizontal_Distance_To_Hydrology\", \"Horizontal_Distance_To_Roadways\", \"Slope\", \"Vertical_Distance_To_Hydrology\", ] CATEGORICAL_FEATURES_WITH_VOCABULARY = { \"Soil_Type\": list(data[\"Soil_Type\"].unique()), \"Wilderness_Area\": list(data[\"Wilderness_Area\"].unique()), } CATEGORICAL_FEATURE_NAMES = list(CATEGORICAL_FEATURES_WITH_VOCABULARY.keys()) FEATURE_NAMES = NUMERIC_FEATURE_NAMES + CATEGORICAL_FEATURE_NAMES COLUMN_DEFAULTS = [ [0] if feature_name in NUMERIC_FEATURE_NAMES + [TARGET_FEATURE_NAME] else [\"NA\"] for feature_name in CSV_HEADER ] NUM_CLASSES = len(TARGET_FEATURE_LABELS) Experiment setup Next, let's define an input function that reads and parses the file, then converts features and labels into atf.data.Dataset for training or evaluation. def get_dataset_from_csv(csv_file_path, batch_size, shuffle=False): dataset = tf.data.experimental.make_csv_dataset( csv_file_path, batch_size=batch_size, column_names=CSV_HEADER, column_defaults=COLUMN_DEFAULTS, label_name=TARGET_FEATURE_NAME, num_epochs=1, header=True, shuffle=shuffle, ) return dataset.cache() Here we configure the parameters and implement the procedure for running a training and evaluation experiment given a model. learning_rate = 0.001 dropout_rate = 0.1 batch_size = 265 num_epochs = 50 hidden_units = [32, 32] def run_experiment(model): model.compile( optimizer=keras.optimizers.Adam(learning_rate=learning_rate), loss=keras.losses.SparseCategoricalCrossentropy(), metrics=[keras.metrics.SparseCategoricalAccuracy()], ) train_dataset = get_dataset_from_csv(train_data_file, batch_size, shuffle=True) test_dataset = get_dataset_from_csv(test_data_file, batch_size) print(\"Start training the model...\") history = model.fit(train_dataset, epochs=num_epochs) print(\"Model training finished\") _, accuracy = model.evaluate(test_dataset, verbose=0) print(f\"Test accuracy: {round(accuracy * 100, 2)}%\") Create model inputs Now, define the inputs for the models as a dictionary, where the key is the feature name, and the value is a keras.layers.Input tensor with the corresponding feature shape and data type. def create_model_inputs(): inputs = {} for feature_name in FEATURE_NAMES: if feature_name in NUMERIC_FEATURE_NAMES: inputs[feature_name] = layers.Input( name=feature_name, shape=(), dtype=tf.float32 ) else: inputs[feature_name] = layers.Input( name=feature_name, shape=(), dtype=tf.string ) return inputs Encode features We create two representations of our input features: sparse and dense: 1. In the sparse representation, the categorical features are encoded with one-hot encoding using the CategoryEncoding layer. This representation can be useful for the model to memorize particular feature values to make certain predictions. 2. In the dense representation, the categorical features are encoded with low-dimensional embeddings using the Embedding layer. This representation helps the model to generalize well to unseen feature combinations. from tensorflow.keras.layers import StringLookup def encode_inputs(inputs, use_embedding=False): encoded_features = [] for feature_name in inputs: if feature_name in CATEGORICAL_FEATURE_NAMES: vocabulary = CATEGORICAL_FEATURES_WITH_VOCABULARY[feature_name] # Create a lookup to convert string values to an integer indices. # Since we are not using a mask token nor expecting any out of vocabulary # (oov) token, we set mask_token to None and num_oov_indices to 0. lookup = StringLookup( vocabulary=vocabulary, mask_token=None, num_oov_indices=0, output_mode=\"int\" if use_embedding else \"binary\", ) if use_embedding: # Convert the string input values into integer indices. encoded_feature = lookup(inputs[feature_name]) embedding_dims = int(math.sqrt(len(vocabulary))) # Create an embedding layer with the specified dimensions. embedding = layers.Embedding( input_dim=len(vocabulary), output_dim=embedding_dims ) # Convert the index values to embedding representations. encoded_feature = embedding(encoded_feature) else: # Convert the string input values into a one hot encoding. encoded_feature = lookup(tf.expand_dims(inputs[feature_name], -1)) else: # Use the numerical features as-is. encoded_feature = tf.expand_dims(inputs[feature_name], -1) encoded_features.append(encoded_feature) all_features = layers.concatenate(encoded_features) return all_features Experiment 1: a baseline model In the first experiment, let's create a multi-layer feed-forward network, where the categorical features are one-hot encoded. def create_baseline_model(): inputs = create_model_inputs() features = encode_inputs(inputs) for units in hidden_units: features = layers.Dense(units)(features) features = layers.BatchNormalization()(features) features = layers.ReLU()(features) features = layers.Dropout(dropout_rate)(features) outputs = layers.Dense(units=NUM_CLASSES, activation=\"softmax\")(features) model = keras.Model(inputs=inputs, outputs=outputs) return model baseline_model = create_baseline_model() keras.utils.plot_model(baseline_model, show_shapes=True, rankdir=\"LR\") ('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.') Let's run it: run_experiment(baseline_model) Start training the model... Epoch 1/50 1862/1862 [==============================] - 10s 5ms/step - loss: 0.9208 - sparse_categorical_accuracy: 0.6334 Epoch 2/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.6758 - sparse_categorical_accuracy: 0.7081 Epoch 3/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.6409 - sparse_categorical_accuracy: 0.7225 Epoch 4/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.6209 - sparse_categorical_accuracy: 0.7316 Epoch 5/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.6074 - sparse_categorical_accuracy: 0.7371 Epoch 6/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5975 - sparse_categorical_accuracy: 0.7419 Epoch 7/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5889 - sparse_categorical_accuracy: 0.7458 Epoch 8/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5846 - sparse_categorical_accuracy: 0.7474 Epoch 9/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5810 - sparse_categorical_accuracy: 0.7502 Epoch 10/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5789 - sparse_categorical_accuracy: 0.7502 Epoch 11/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5746 - sparse_categorical_accuracy: 0.7528 Epoch 12/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5718 - sparse_categorical_accuracy: 0.7540 Epoch 13/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5689 - sparse_categorical_accuracy: 0.7551 Epoch 14/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5671 - sparse_categorical_accuracy: 0.7558 Epoch 15/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5650 - sparse_categorical_accuracy: 0.7568 Epoch 16/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5623 - sparse_categorical_accuracy: 0.7577 Epoch 17/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5616 - sparse_categorical_accuracy: 0.7591 Epoch 18/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5583 - sparse_categorical_accuracy: 0.7590 Epoch 19/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5577 - sparse_categorical_accuracy: 0.7593 Epoch 20/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5549 - sparse_categorical_accuracy: 0.7608 Epoch 21/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5564 - sparse_categorical_accuracy: 0.7599 Epoch 22/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5554 - sparse_categorical_accuracy: 0.7606 Epoch 23/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5537 - sparse_categorical_accuracy: 0.7617 Epoch 24/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5518 - sparse_categorical_accuracy: 0.7624 Epoch 25/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5508 - sparse_categorical_accuracy: 0.7618 Epoch 26/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5498 - sparse_categorical_accuracy: 0.7621 Epoch 27/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5497 - sparse_categorical_accuracy: 0.7623 Epoch 28/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5482 - sparse_categorical_accuracy: 0.7645 Epoch 29/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5467 - sparse_categorical_accuracy: 0.7637 Epoch 30/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5469 - sparse_categorical_accuracy: 0.7638 Epoch 31/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5457 - sparse_categorical_accuracy: 0.7641 Epoch 32/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5448 - sparse_categorical_accuracy: 0.7647 Epoch 33/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5440 - sparse_categorical_accuracy: 0.7644 Epoch 34/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5448 - sparse_categorical_accuracy: 0.7653 Epoch 35/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5424 - sparse_categorical_accuracy: 0.7652 Epoch 36/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5416 - sparse_categorical_accuracy: 0.7666 Epoch 37/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5411 - sparse_categorical_accuracy: 0.7663 Epoch 38/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5399 - sparse_categorical_accuracy: 0.7673 Epoch 39/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5410 - sparse_categorical_accuracy: 0.7664 Epoch 40/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5402 - sparse_categorical_accuracy: 0.7668 Epoch 41/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5395 - sparse_categorical_accuracy: 0.7670 Epoch 42/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5382 - sparse_categorical_accuracy: 0.7679 Epoch 43/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5369 - sparse_categorical_accuracy: 0.7680 Epoch 44/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5370 - sparse_categorical_accuracy: 0.7686 Epoch 45/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5358 - sparse_categorical_accuracy: 0.7680 Epoch 46/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5358 - sparse_categorical_accuracy: 0.7698 Epoch 47/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5363 - sparse_categorical_accuracy: 0.7697 Epoch 48/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5349 - sparse_categorical_accuracy: 0.7691 Epoch 49/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5357 - sparse_categorical_accuracy: 0.7691 Epoch 50/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5338 - sparse_categorical_accuracy: 0.7697 Model training finished Test accuracy: 75.72% The baseline linear model achieves ~76% test accuracy. Experiment 2: Wide & Deep model In the second experiment, we create a Wide & Deep model. The wide part of the model a linear model, while the deep part of the model is a multi-layer feed-forward network. Use the sparse representation of the input features in the wide part of the model and the dense representation of the input features for the deep part of the model. Note that every input features contributes to both parts of the model with different representations. def create_wide_and_deep_model(): inputs = create_model_inputs() wide = encode_inputs(inputs) wide = layers.BatchNormalization()(wide) deep = encode_inputs(inputs, use_embedding=True) for units in hidden_units: deep = layers.Dense(units)(deep) deep = layers.BatchNormalization()(deep) deep = layers.ReLU()(deep) deep = layers.Dropout(dropout_rate)(deep) merged = layers.concatenate([wide, deep]) outputs = layers.Dense(units=NUM_CLASSES, activation=\"softmax\")(merged) model = keras.Model(inputs=inputs, outputs=outputs) return model wide_and_deep_model = create_wide_and_deep_model() keras.utils.plot_model(wide_and_deep_model, show_shapes=True, rankdir=\"LR\") ('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.') Let's run it: run_experiment(wide_and_deep_model) Start training the model... Epoch 1/50 1862/1862 [==============================] - 11s 5ms/step - loss: 0.8994 - sparse_categorical_accuracy: 0.6469 Epoch 2/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.6112 - sparse_categorical_accuracy: 0.7350 Epoch 3/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5936 - sparse_categorical_accuracy: 0.7426 Epoch 4/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5814 - sparse_categorical_accuracy: 0.7468 Epoch 5/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5716 - sparse_categorical_accuracy: 0.7517 Epoch 6/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5652 - sparse_categorical_accuracy: 0.7553 Epoch 7/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5595 - sparse_categorical_accuracy: 0.7581 Epoch 8/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5542 - sparse_categorical_accuracy: 0.7600 Epoch 9/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5498 - sparse_categorical_accuracy: 0.7631 Epoch 10/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5459 - sparse_categorical_accuracy: 0.7647 Epoch 11/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5427 - sparse_categorical_accuracy: 0.7655 Epoch 12/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5398 - sparse_categorical_accuracy: 0.7675 Epoch 13/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5360 - sparse_categorical_accuracy: 0.7695 Epoch 14/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5335 - sparse_categorical_accuracy: 0.7697 Epoch 15/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5310 - sparse_categorical_accuracy: 0.7709 Epoch 16/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5289 - sparse_categorical_accuracy: 0.7725 Epoch 17/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5263 - sparse_categorical_accuracy: 0.7739 Epoch 18/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5255 - sparse_categorical_accuracy: 0.7745 Epoch 19/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5235 - sparse_categorical_accuracy: 0.7750 Epoch 20/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5224 - sparse_categorical_accuracy: 0.7757 Epoch 21/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5216 - sparse_categorical_accuracy: 0.7770 Epoch 22/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5205 - sparse_categorical_accuracy: 0.7771 Epoch 23/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5191 - sparse_categorical_accuracy: 0.7769 Epoch 24/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5189 - sparse_categorical_accuracy: 0.7779 Epoch 25/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5166 - sparse_categorical_accuracy: 0.7793 Epoch 26/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5160 - sparse_categorical_accuracy: 0.7794 Epoch 27/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5146 - sparse_categorical_accuracy: 0.7791 Epoch 28/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5136 - sparse_categorical_accuracy: 0.7810 Epoch 29/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5125 - sparse_categorical_accuracy: 0.7809 Epoch 30/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5124 - sparse_categorical_accuracy: 0.7806 Epoch 31/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5112 - sparse_categorical_accuracy: 0.7808 Epoch 32/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5098 - sparse_categorical_accuracy: 0.7822 Epoch 33/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5097 - sparse_categorical_accuracy: 0.7808 Epoch 34/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5094 - sparse_categorical_accuracy: 0.7819 Epoch 35/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5084 - sparse_categorical_accuracy: 0.7823 Epoch 36/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5077 - sparse_categorical_accuracy: 0.7826 Epoch 37/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5067 - sparse_categorical_accuracy: 0.7830 Epoch 38/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5063 - sparse_categorical_accuracy: 0.7834 Epoch 39/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5058 - sparse_categorical_accuracy: 0.7841 Epoch 40/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5047 - sparse_categorical_accuracy: 0.7840 Epoch 41/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5041 - sparse_categorical_accuracy: 0.7848 Epoch 42/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5024 - sparse_categorical_accuracy: 0.7857 Epoch 43/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5020 - sparse_categorical_accuracy: 0.7857 Epoch 44/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5009 - sparse_categorical_accuracy: 0.7865 Epoch 45/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4998 - sparse_categorical_accuracy: 0.7868 Epoch 46/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5000 - sparse_categorical_accuracy: 0.7864 Epoch 47/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4985 - sparse_categorical_accuracy: 0.7876 Epoch 48/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4985 - sparse_categorical_accuracy: 0.7877 Epoch 49/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4979 - sparse_categorical_accuracy: 0.7876 Epoch 50/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4973 - sparse_categorical_accuracy: 0.7881 Model training finished Test accuracy: 80.69% The wide and deep model achieves ~79% test accuracy. Experiment 3: Deep & Cross model In the third experiment, we create a Deep & Cross model. The deep part of this model is the same as the deep part created in the previous experiment. The key idea of the cross part is to apply explicit feature crossing in an efficient way, where the degree of cross features grows with layer depth. def create_deep_and_cross_model(): inputs = create_model_inputs() x0 = encode_inputs(inputs, use_embedding=True) cross = x0 for _ in hidden_units: units = cross.shape[-1] x = layers.Dense(units)(cross) cross = x0 * x + cross cross = layers.BatchNormalization()(cross) deep = x0 for units in hidden_units: deep = layers.Dense(units)(deep) deep = layers.BatchNormalization()(deep) deep = layers.ReLU()(deep) deep = layers.Dropout(dropout_rate)(deep) merged = layers.concatenate([cross, deep]) outputs = layers.Dense(units=NUM_CLASSES, activation=\"softmax\")(merged) model = keras.Model(inputs=inputs, outputs=outputs) return model deep_and_cross_model = create_deep_and_cross_model() keras.utils.plot_model(deep_and_cross_model, show_shapes=True, rankdir=\"LR\") ('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.') Let's run it: run_experiment(deep_and_cross_model) Start training the model... Epoch 1/50 1862/1862 [==============================] - 11s 5ms/step - loss: 0.8585 - sparse_categorical_accuracy: 0.6547 Epoch 2/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5968 - sparse_categorical_accuracy: 0.7424 Epoch 3/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5729 - sparse_categorical_accuracy: 0.7520 Epoch 4/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5610 - sparse_categorical_accuracy: 0.7583 Epoch 5/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5511 - sparse_categorical_accuracy: 0.7623 Epoch 6/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5460 - sparse_categorical_accuracy: 0.7651 Epoch 7/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5408 - sparse_categorical_accuracy: 0.7671 Epoch 8/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5374 - sparse_categorical_accuracy: 0.7695 Epoch 9/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5344 - sparse_categorical_accuracy: 0.7704 Epoch 10/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5310 - sparse_categorical_accuracy: 0.7715 Epoch 11/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5286 - sparse_categorical_accuracy: 0.7725 Epoch 12/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5254 - sparse_categorical_accuracy: 0.7737 Epoch 13/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5249 - sparse_categorical_accuracy: 0.7737 Epoch 14/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5223 - sparse_categorical_accuracy: 0.7752 Epoch 15/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5206 - sparse_categorical_accuracy: 0.7759 Epoch 16/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5187 - sparse_categorical_accuracy: 0.7765 Epoch 17/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5179 - sparse_categorical_accuracy: 0.7772 Epoch 18/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5152 - sparse_categorical_accuracy: 0.7788 Epoch 19/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5145 - sparse_categorical_accuracy: 0.7785 Epoch 20/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5128 - sparse_categorical_accuracy: 0.7800 Epoch 21/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5117 - sparse_categorical_accuracy: 0.7803 Epoch 22/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5105 - sparse_categorical_accuracy: 0.7809 Epoch 23/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5089 - sparse_categorical_accuracy: 0.7813 Epoch 24/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5074 - sparse_categorical_accuracy: 0.7823 Epoch 25/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5061 - sparse_categorical_accuracy: 0.7821 Epoch 26/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5048 - sparse_categorical_accuracy: 0.7832 Epoch 27/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5037 - sparse_categorical_accuracy: 0.7837 Epoch 28/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5017 - sparse_categorical_accuracy: 0.7846 Epoch 29/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.5010 - sparse_categorical_accuracy: 0.7851 Epoch 30/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4991 - sparse_categorical_accuracy: 0.7861 Epoch 31/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4989 - sparse_categorical_accuracy: 0.7849 Epoch 32/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4979 - sparse_categorical_accuracy: 0.7865 Epoch 33/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4961 - sparse_categorical_accuracy: 0.7867 Epoch 34/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4955 - sparse_categorical_accuracy: 0.7871 Epoch 35/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4946 - sparse_categorical_accuracy: 0.7871 Epoch 36/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4946 - sparse_categorical_accuracy: 0.7873 Epoch 37/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4925 - sparse_categorical_accuracy: 0.7877 Epoch 38/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4920 - sparse_categorical_accuracy: 0.7884 Epoch 39/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4910 - sparse_categorical_accuracy: 0.7887 Epoch 40/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4909 - sparse_categorical_accuracy: 0.7883 Epoch 41/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4906 - sparse_categorical_accuracy: 0.7890 Epoch 42/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4883 - sparse_categorical_accuracy: 0.7892 Epoch 43/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4883 - sparse_categorical_accuracy: 0.7896 Epoch 44/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4875 - sparse_categorical_accuracy: 0.7908 Epoch 45/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4866 - sparse_categorical_accuracy: 0.7900 Epoch 46/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4864 - sparse_categorical_accuracy: 0.7902 Epoch 47/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4862 - sparse_categorical_accuracy: 0.7909 Epoch 48/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4849 - sparse_categorical_accuracy: 0.7908 Epoch 49/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4843 - sparse_categorical_accuracy: 0.7910 Epoch 50/50 1862/1862 [==============================] - 5s 3ms/step - loss: 0.4841 - sparse_categorical_accuracy: 0.7921 Model training finished Test accuracy: 80.61% The deep and cross model achieves ~81% test accuracy. Conclusion You can use Keras Preprocessing Layers to easily handle categorical features with different encoding mechanisms, including one-hot encoding and feature embedding. In addition, different model architectures — like wide, deep, and cross networks — have different advantages, with respect to different dataset properties. You can explore using them independently or combining them to achieve the best result for your dataset. Detect anomalies in a timeseries using an Autoencoder. Introduction This script demonstrates how you can use a reconstruction convolutional autoencoder model to detect anomalies in timeseries data. Setup import numpy as np import pandas as pd from tensorflow import keras from tensorflow.keras import layers from matplotlib import pyplot as plt Load the data We will use the Numenta Anomaly Benchmark(NAB) dataset. It provides artifical timeseries data containing labeled anomalous periods of behavior. Data are ordered, timestamped, single-valued metrics. We will use the art_daily_small_noise.csv file for training and the art_daily_jumpsup.csv file for testing. The simplicity of this dataset allows us to demonstrate anomaly detection effectively. master_url_root = \"https://raw.githubusercontent.com/numenta/NAB/master/data/\" df_small_noise_url_suffix = \"artificialNoAnomaly/art_daily_small_noise.csv\" df_small_noise_url = master_url_root + df_small_noise_url_suffix df_small_noise = pd.read_csv( df_small_noise_url, parse_dates=True, index_col=\"timestamp\" ) df_daily_jumpsup_url_suffix = \"artificialWithAnomaly/art_daily_jumpsup.csv\" df_daily_jumpsup_url = master_url_root + df_daily_jumpsup_url_suffix df_daily_jumpsup = pd.read_csv( df_daily_jumpsup_url, parse_dates=True, index_col=\"timestamp\" ) Quick look at the data print(df_small_noise.head()) print(df_daily_jumpsup.head()) value timestamp 2014-04-01 00:00:00 18.324919 2014-04-01 00:05:00 21.970327 2014-04-01 00:10:00 18.624806 2014-04-01 00:15:00 21.953684 2014-04-01 00:20:00 21.909120 value timestamp 2014-04-01 00:00:00 19.761252 2014-04-01 00:05:00 20.500833 2014-04-01 00:10:00 19.961641 2014-04-01 00:15:00 21.490266 2014-04-01 00:20:00 20.187739 Visualize the data Timeseries data without anomalies We will use the following data for training. fig, ax = plt.subplots() df_small_noise.plot(legend=False, ax=ax) plt.show() png Timeseries data with anomalies We will use the following data for testing and see if the sudden jump up in the data is detected as an anomaly. fig, ax = plt.subplots() df_daily_jumpsup.plot(legend=False, ax=ax) plt.show() png Prepare training data Get data values from the training timeseries data file and normalize the value data. We have a value for every 5 mins for 14 days. 24 * 60 / 5 = 288 timesteps per day 288 * 14 = 4032 data points in total # Normalize and save the mean and std we get, # for normalizing test data. training_mean = df_small_noise.mean() training_std = df_small_noise.std() df_training_value = (df_small_noise - training_mean) / training_std print(\"Number of training samples:\", len(df_training_value)) Number of training samples: 4032 Create sequences Create sequences combining TIME_STEPS contiguous data values from the training data. TIME_STEPS = 288 # Generated training sequences for use in the model. def create_sequences(values, time_steps=TIME_STEPS): output = [] for i in range(len(values) - time_steps + 1): output.append(values[i : (i + time_steps)]) return np.stack(output) x_train = create_sequences(df_training_value.values) print(\"Training input shape: \", x_train.shape) Training input shape: (3745, 288, 1) Build a model We will build a convolutional reconstruction autoencoder model. The model will take input of shape (batch_size, sequence_length, num_features) and return output of the same shape. In this case, sequence_length is 288 and num_features is 1. model = keras.Sequential( [ layers.Input(shape=(x_train.shape[1], x_train.shape[2])), layers.Conv1D( filters=32, kernel_size=7, padding=\"same\", strides=2, activation=\"relu\" ), layers.Dropout(rate=0.2), layers.Conv1D( filters=16, kernel_size=7, padding=\"same\", strides=2, activation=\"relu\" ), layers.Conv1DTranspose( filters=16, kernel_size=7, padding=\"same\", strides=2, activation=\"relu\" ), layers.Dropout(rate=0.2), layers.Conv1DTranspose( filters=32, kernel_size=7, padding=\"same\", strides=2, activation=\"relu\" ), layers.Conv1DTranspose(filters=1, kernel_size=7, padding=\"same\"), ] ) model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss=\"mse\") model.summary() WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of [`keras.Input`](/api/layers/core_layers/input#input-function) to Sequential model. [`keras.Input`](/api/layers/core_layers/input#input-function) is intended to be used by Functional model. Model: \"sequential\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv1d (Conv1D) (None, 144, 32) 256 _________________________________________________________________ dropout (Dropout) (None, 144, 32) 0 _________________________________________________________________ conv1d_1 (Conv1D) (None, 72, 16) 3600 _________________________________________________________________ conv1d_transpose (Conv1DTran (None, 144, 16) 1808 _________________________________________________________________ dropout_1 (Dropout) (None, 144, 16) 0 _________________________________________________________________ conv1d_transpose_1 (Conv1DTr (None, 288, 32) 3616 _________________________________________________________________ conv1d_transpose_2 (Conv1DTr (None, 288, 1) 225 ================================================================= Total params: 9,505 Trainable params: 9,505 Non-trainable params: 0 _________________________________________________________________ Train the model Please note that we are using x_train as both the input and the target since this is a reconstruction model. history = model.fit( x_train, x_train, epochs=50, batch_size=128, validation_split=0.1, callbacks=[ keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=5, mode=\"min\") ], ) Epoch 1/50 27/27 [==============================] - 2s 35ms/step - loss: 0.5868 - val_loss: 0.1225 Epoch 2/50 27/27 [==============================] - 1s 29ms/step - loss: 0.0882 - val_loss: 0.0404 Epoch 3/50 27/27 [==============================] - 1s 30ms/step - loss: 0.0594 - val_loss: 0.0359 Epoch 4/50 27/27 [==============================] - 1s 29ms/step - loss: 0.0486 - val_loss: 0.0287 Epoch 5/50 27/27 [==============================] - 1s 30ms/step - loss: 0.0398 - val_loss: 0.0231 Epoch 6/50 27/27 [==============================] - 1s 31ms/step - loss: 0.0337 - val_loss: 0.0208 Epoch 7/50 27/27 [==============================] - 1s 31ms/step - loss: 0.0299 - val_loss: 0.0182 Epoch 8/50 27/27 [==============================] - 1s 31ms/step - loss: 0.0271 - val_loss: 0.0187 Epoch 9/50 27/27 [==============================] - 1s 32ms/step - loss: 0.0251 - val_loss: 0.0190 Epoch 10/50 27/27 [==============================] - 1s 31ms/step - loss: 0.0235 - val_loss: 0.0179 Epoch 11/50 27/27 [==============================] - 1s 32ms/step - loss: 0.0224 - val_loss: 0.0189 Epoch 12/50 27/27 [==============================] - 1s 33ms/step - loss: 0.0214 - val_loss: 0.0199 Epoch 13/50 27/27 [==============================] - 1s 33ms/step - loss: 0.0206 - val_loss: 0.0194 Epoch 14/50 27/27 [==============================] - 1s 32ms/step - loss: 0.0199 - val_loss: 0.0208 Epoch 15/50 27/27 [==============================] - 1s 35ms/step - loss: 0.0192 - val_loss: 0.0204 Let's plot training and validation loss to see how the training went. plt.plot(history.history[\"loss\"], label=\"Training Loss\") plt.plot(history.history[\"val_loss\"], label=\"Validation Loss\") plt.legend() plt.show() png Detecting anomalies We will detect anomalies by determining how well our model can reconstruct the input data. Find MAE loss on training samples. Find max MAE loss value. This is the worst our model has performed trying to reconstruct a sample. We will make this the threshold for anomaly detection. If the reconstruction loss for a sample is greater than this threshold value then we can infer that the model is seeing a pattern that it isn't familiar with. We will label this sample as an anomaly. # Get train MAE loss. x_train_pred = model.predict(x_train) train_mae_loss = np.mean(np.abs(x_train_pred - x_train), axis=1) plt.hist(train_mae_loss, bins=50) plt.xlabel(\"Train MAE loss\") plt.ylabel(\"No of samples\") plt.show() # Get reconstruction loss threshold. threshold = np.max(train_mae_loss) print(\"Reconstruction error threshold: \", threshold) png Reconstruction error threshold: 0.1195600905852785 Compare recontruction Just for fun, let's see how our model has recontructed the first sample. This is the 288 timesteps from day 1 of our training dataset. # Checking how the first sequence is learnt plt.plot(x_train[0]) plt.plot(x_train_pred[0]) plt.show() png Prepare test data df_test_value = (df_daily_jumpsup - training_mean) / training_std fig, ax = plt.subplots() df_test_value.plot(legend=False, ax=ax) plt.show() # Create sequences from test values. x_test = create_sequences(df_test_value.values) print(\"Test input shape: \", x_test.shape) # Get test MAE loss. x_test_pred = model.predict(x_test) test_mae_loss = np.mean(np.abs(x_test_pred - x_test), axis=1) test_mae_loss = test_mae_loss.reshape((-1)) plt.hist(test_mae_loss, bins=50) plt.xlabel(\"test MAE loss\") plt.ylabel(\"No of samples\") plt.show() # Detect all the samples which are anomalies. anomalies = test_mae_loss > threshold print(\"Number of anomaly samples: \", np.sum(anomalies)) print(\"Indices of anomaly samples: \", np.where(anomalies)) png Test input shape: (3745, 288, 1) png Number of anomaly samples: 399 Indices of anomaly samples: (array([ 789, 1653, 1654, 1941, 2697, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713, 2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725, 2726, 2727, 2728, 2729, 2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, 2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754, 2755, 2756, 2757, 2758, 2759, 2760, 2761, 2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 2770, 2771, 2772, 2773, 2774, 2775, 2776, 2777, 2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793, 2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809, 2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, 2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825, 2826, 2827, 2828, 2829, 2830, 2831, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841, 2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849, 2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857, 2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 2866, 2867, 2868, 2869, 2870, 2871, 2872, 2873, 2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889, 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905, 2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921, 2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985, 2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095]),) Plot anomalies We now know the samples of the data which are anomalies. With this, we will find the corresponding timestamps from the original test data. We will be using the following method to do that: Let's say time_steps = 3 and we have 10 training values. Our x_train will look like this: 0, 1, 2 1, 2, 3 2, 3, 4 3, 4, 5 4, 5, 6 5, 6, 7 6, 7, 8 7, 8, 9 All except the initial and the final time_steps-1 data values, will appear in time_steps number of samples. So, if we know that the samples [(3, 4, 5), (4, 5, 6), (5, 6, 7)] are anomalies, we can say that the data point 5 is an anomaly. # data i is an anomaly if samples [(i - timesteps + 1) to (i)] are anomalies anomalous_data_indices = [] for data_idx in range(TIME_STEPS - 1, len(df_test_value) - TIME_STEPS + 1): if np.all(anomalies[data_idx - TIME_STEPS + 1 : data_idx]): anomalous_data_indices.append(data_idx) Let's overlay the anomalies on the original test data plot. df_subset = df_daily_jumpsup.iloc[anomalous_data_indices] fig, ax = plt.subplots() df_daily_jumpsup.plot(legend=False, ax=ax) df_subset.plot(legend=False, ax=ax, color=\"r\") plt.show() png Training a timeseries classifier from scratch on the FordA dataset from the UCR/UEA archive. Introduction This example shows how to do timeseries classification from scratch, starting from raw CSV timeseries files on disk. We demonstrate the workflow on the FordA dataset from the UCR/UEA archive. Setup from tensorflow import keras import numpy as np import matplotlib.pyplot as plt Load the data: the FordA dataset Dataset description The dataset we are using here is called FordA. The data comes from the UCR archive. The dataset contains 3601 training instances and another 1320 testing instances. Each timeseries corresponds to a measurement of engine noise captured by a motor sensor. For this task, the goal is to automatically detect the presence of a specific issue with the engine. The problem is a balanced binary classification task. The full description of this dataset can be found here. Read the TSV data We will use the FordA_TRAIN file for training and the FordA_TEST file for testing. The simplicity of this dataset allows us to demonstrate effectively how to use ConvNets for timeseries classification. In this file, the first column corresponds to the label. def readucr(filename): data = np.loadtxt(filename, delimiter=\"\t\") y = data[:, 0] x = data[:, 1:] return x, y.astype(int) root_url = \"https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/\" x_train, y_train = readucr(root_url + \"FordA_TRAIN.tsv\") x_test, y_test = readucr(root_url + \"FordA_TEST.tsv\") Visualize the data Here we visualize one timeseries example for each class in the dataset. classes = np.unique(np.concatenate((y_train, y_test), axis=0)) plt.figure() for c in classes: c_x_train = x_train[y_train == c] plt.plot(c_x_train[0], label=\"class \" + str(c)) plt.legend(loc=\"best\") plt.show() plt.close() png Standardize the data Our timeseries are already in a single length (500). However, their values are usually in various ranges. This is not ideal for a neural network; in general we should seek to make the input values normalized. For this specific dataset, the data is already z-normalized: each timeseries sample has a mean equal to zero and a standard deviation equal to one. This type of normalization is very common for timeseries classification problems, see Bagnall et al. (2016). Note that the timeseries data used here are univariate, meaning we only have one channel per timeseries example. We will therefore transform the timeseries into a multivariate one with one channel using a simple reshaping via numpy. This will allow us to construct a model that is easily applicable to multivariate time series. x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], 1)) x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], 1)) Finally, in order to use sparse_categorical_crossentropy, we will have to count the number of classes beforehand. num_classes = len(np.unique(y_train)) Now we shuffle the training set because we will be using the validation_split option later when training. idx = np.random.permutation(len(x_train)) x_train = x_train[idx] y_train = y_train[idx] Standardize the labels to positive integers. The expected labels will then be 0 and 1. y_train[y_train == -1] = 0 y_test[y_test == -1] = 0 Build a model We build a Fully Convolutional Neural Network originally proposed in this paper. The implementation is based on the TF 2 version provided here. The following hyperparameters (kernel_size, filters, the usage of BatchNorm) were found via random search using KerasTuner. def make_model(input_shape): input_layer = keras.layers.Input(input_shape) conv1 = keras.layers.Conv1D(filters=64, kernel_size=3, padding=\"same\")(input_layer) conv1 = keras.layers.BatchNormalization()(conv1) conv1 = keras.layers.ReLU()(conv1) conv2 = keras.layers.Conv1D(filters=64, kernel_size=3, padding=\"same\")(conv1) conv2 = keras.layers.BatchNormalization()(conv2) conv2 = keras.layers.ReLU()(conv2) conv3 = keras.layers.Conv1D(filters=64, kernel_size=3, padding=\"same\")(conv2) conv3 = keras.layers.BatchNormalization()(conv3) conv3 = keras.layers.ReLU()(conv3) gap = keras.layers.GlobalAveragePooling1D()(conv3) output_layer = keras.layers.Dense(num_classes, activation=\"softmax\")(gap) return keras.models.Model(inputs=input_layer, outputs=output_layer) model = make_model(input_shape=x_train.shape[1:]) keras.utils.plot_model(model, show_shapes=True) ('Failed to import pydot. You must `pip install pydot` and install graphviz (https://graphviz.gitlab.io/download/), ', 'for `pydotprint` to work.') Train the model epochs = 500 batch_size = 32 callbacks = [ keras.callbacks.ModelCheckpoint( \"best_model.h5\", save_best_only=True, monitor=\"val_loss\" ), keras.callbacks.ReduceLROnPlateau( monitor=\"val_loss\", factor=0.5, patience=20, min_lr=0.0001 ), keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=50, verbose=1), ] model.compile( optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"sparse_categorical_accuracy\"], ) history = model.fit( x_train, y_train, batch_size=batch_size, epochs=epochs, callbacks=callbacks, validation_split=0.2, verbose=1, ) Epoch 1/500 90/90 [==============================] - 1s 8ms/step - loss: 0.5531 - sparse_categorical_accuracy: 0.7017 - val_loss: 0.7335 - val_sparse_categorical_accuracy: 0.4882 Epoch 2/500 90/90 [==============================] - 1s 6ms/step - loss: 0.4520 - sparse_categorical_accuracy: 0.7729 - val_loss: 0.7446 - val_sparse_categorical_accuracy: 0.4882 Epoch 3/500 90/90 [==============================] - 1s 6ms/step - loss: 0.4404 - sparse_categorical_accuracy: 0.7733 - val_loss: 0.7706 - val_sparse_categorical_accuracy: 0.4882 Epoch 4/500 90/90 [==============================] - 1s 6ms/step - loss: 0.4234 - sparse_categorical_accuracy: 0.7899 - val_loss: 0.9741 - val_sparse_categorical_accuracy: 0.4882 Epoch 5/500 90/90 [==============================] - 1s 6ms/step - loss: 0.4180 - sparse_categorical_accuracy: 0.7972 - val_loss: 0.6679 - val_sparse_categorical_accuracy: 0.5936 Epoch 6/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3988 - sparse_categorical_accuracy: 0.8066 - val_loss: 0.5399 - val_sparse_categorical_accuracy: 0.6990 Epoch 7/500 90/90 [==============================] - 1s 6ms/step - loss: 0.4012 - sparse_categorical_accuracy: 0.8024 - val_loss: 0.4051 - val_sparse_categorical_accuracy: 0.8225 Epoch 8/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3903 - sparse_categorical_accuracy: 0.8080 - val_loss: 0.9671 - val_sparse_categorical_accuracy: 0.5340 Epoch 9/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3948 - sparse_categorical_accuracy: 0.7986 - val_loss: 0.5778 - val_sparse_categorical_accuracy: 0.6436 Epoch 10/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3731 - sparse_categorical_accuracy: 0.8260 - val_loss: 0.4307 - val_sparse_categorical_accuracy: 0.7698 Epoch 11/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3645 - sparse_categorical_accuracy: 0.8260 - val_loss: 0.4010 - val_sparse_categorical_accuracy: 0.7698 Epoch 12/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3666 - sparse_categorical_accuracy: 0.8247 - val_loss: 0.3574 - val_sparse_categorical_accuracy: 0.8350 Epoch 13/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3618 - sparse_categorical_accuracy: 0.8271 - val_loss: 0.3942 - val_sparse_categorical_accuracy: 0.8044 Epoch 14/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3619 - sparse_categorical_accuracy: 0.8257 - val_loss: 0.4104 - val_sparse_categorical_accuracy: 0.7906 Epoch 15/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3353 - sparse_categorical_accuracy: 0.8521 - val_loss: 0.3819 - val_sparse_categorical_accuracy: 0.7684 Epoch 16/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3287 - sparse_categorical_accuracy: 0.8514 - val_loss: 0.3776 - val_sparse_categorical_accuracy: 0.8252 Epoch 17/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3299 - sparse_categorical_accuracy: 0.8545 - val_loss: 0.3555 - val_sparse_categorical_accuracy: 0.8350 Epoch 18/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3206 - sparse_categorical_accuracy: 0.8601 - val_loss: 0.4051 - val_sparse_categorical_accuracy: 0.7906 Epoch 19/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3125 - sparse_categorical_accuracy: 0.8608 - val_loss: 0.3792 - val_sparse_categorical_accuracy: 0.8114 Epoch 20/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3052 - sparse_categorical_accuracy: 0.8750 - val_loss: 0.3448 - val_sparse_categorical_accuracy: 0.8377 Epoch 21/500 90/90 [==============================] - 1s 6ms/step - loss: 0.3023 - sparse_categorical_accuracy: 0.8736 - val_loss: 0.3325 - val_sparse_categorical_accuracy: 0.8363 Epoch 22/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2955 - sparse_categorical_accuracy: 0.8736 - val_loss: 0.3447 - val_sparse_categorical_accuracy: 0.8225 Epoch 23/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2934 - sparse_categorical_accuracy: 0.8788 - val_loss: 0.2943 - val_sparse_categorical_accuracy: 0.8779 Epoch 24/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2972 - sparse_categorical_accuracy: 0.8715 - val_loss: 0.4946 - val_sparse_categorical_accuracy: 0.7462 Epoch 25/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2800 - sparse_categorical_accuracy: 0.8865 - val_loss: 0.2860 - val_sparse_categorical_accuracy: 0.8821 Epoch 26/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2752 - sparse_categorical_accuracy: 0.8847 - val_loss: 0.2924 - val_sparse_categorical_accuracy: 0.8655 Epoch 27/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2769 - sparse_categorical_accuracy: 0.8847 - val_loss: 0.6254 - val_sparse_categorical_accuracy: 0.6879 Epoch 28/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2821 - sparse_categorical_accuracy: 0.8799 - val_loss: 0.2764 - val_sparse_categorical_accuracy: 0.8821 Epoch 29/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2713 - sparse_categorical_accuracy: 0.8892 - val_loss: 0.7015 - val_sparse_categorical_accuracy: 0.6422 Epoch 30/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2633 - sparse_categorical_accuracy: 0.8885 - val_loss: 0.8508 - val_sparse_categorical_accuracy: 0.7254 Epoch 31/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2673 - sparse_categorical_accuracy: 0.8896 - val_loss: 0.4354 - val_sparse_categorical_accuracy: 0.7725 Epoch 32/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2518 - sparse_categorical_accuracy: 0.8997 - val_loss: 0.9172 - val_sparse_categorical_accuracy: 0.6394 Epoch 33/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2484 - sparse_categorical_accuracy: 0.9024 - val_loss: 0.5055 - val_sparse_categorical_accuracy: 0.7531 Epoch 34/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2352 - sparse_categorical_accuracy: 0.9059 - val_loss: 0.6289 - val_sparse_categorical_accuracy: 0.7115 Epoch 35/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2389 - sparse_categorical_accuracy: 0.9104 - val_loss: 0.2776 - val_sparse_categorical_accuracy: 0.8946 Epoch 36/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2218 - sparse_categorical_accuracy: 0.9122 - val_loss: 1.3105 - val_sparse_categorical_accuracy: 0.6408 Epoch 37/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2237 - sparse_categorical_accuracy: 0.9125 - val_loss: 0.4860 - val_sparse_categorical_accuracy: 0.7628 Epoch 38/500 90/90 [==============================] - 1s 6ms/step - loss: 0.2008 - sparse_categorical_accuracy: 0.9281 - val_loss: 0.5553 - val_sparse_categorical_accuracy: 0.7226 Epoch 39/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1999 - sparse_categorical_accuracy: 0.9233 - val_loss: 0.4511 - val_sparse_categorical_accuracy: 0.8058 Epoch 40/500 90/90 [==============================] - 0s 6ms/step - loss: 0.1857 - sparse_categorical_accuracy: 0.9330 - val_loss: 0.2912 - val_sparse_categorical_accuracy: 0.8516 Epoch 41/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1736 - sparse_categorical_accuracy: 0.9399 - val_loss: 0.9930 - val_sparse_categorical_accuracy: 0.5506 Epoch 42/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1649 - sparse_categorical_accuracy: 0.9396 - val_loss: 0.5852 - val_sparse_categorical_accuracy: 0.7198 Epoch 43/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1501 - sparse_categorical_accuracy: 0.9538 - val_loss: 0.1911 - val_sparse_categorical_accuracy: 0.9168 Epoch 44/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1512 - sparse_categorical_accuracy: 0.9455 - val_loss: 0.8169 - val_sparse_categorical_accuracy: 0.6130 Epoch 45/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1358 - sparse_categorical_accuracy: 0.9552 - val_loss: 0.4748 - val_sparse_categorical_accuracy: 0.7795 Epoch 46/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1401 - sparse_categorical_accuracy: 0.9535 - val_loss: 1.7678 - val_sparse_categorical_accuracy: 0.5881 Epoch 47/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1444 - sparse_categorical_accuracy: 0.9545 - val_loss: 1.7005 - val_sparse_categorical_accuracy: 0.5950 Epoch 48/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1320 - sparse_categorical_accuracy: 0.9542 - val_loss: 0.1550 - val_sparse_categorical_accuracy: 0.9431 Epoch 49/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1333 - sparse_categorical_accuracy: 0.9576 - val_loss: 0.1665 - val_sparse_categorical_accuracy: 0.9362 Epoch 50/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1367 - sparse_categorical_accuracy: 0.9549 - val_loss: 0.4227 - val_sparse_categorical_accuracy: 0.8308 Epoch 51/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1391 - sparse_categorical_accuracy: 0.9503 - val_loss: 0.1729 - val_sparse_categorical_accuracy: 0.9390 Epoch 52/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1237 - sparse_categorical_accuracy: 0.9573 - val_loss: 0.1338 - val_sparse_categorical_accuracy: 0.9487 Epoch 53/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1397 - sparse_categorical_accuracy: 0.9531 - val_loss: 0.1667 - val_sparse_categorical_accuracy: 0.9487 Epoch 54/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1205 - sparse_categorical_accuracy: 0.9601 - val_loss: 0.2904 - val_sparse_categorical_accuracy: 0.8821 Epoch 55/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1302 - sparse_categorical_accuracy: 0.9538 - val_loss: 0.9437 - val_sparse_categorical_accuracy: 0.7060 Epoch 56/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1241 - sparse_categorical_accuracy: 0.9580 - val_loss: 0.1346 - val_sparse_categorical_accuracy: 0.9501 Epoch 57/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1158 - sparse_categorical_accuracy: 0.9646 - val_loss: 0.9489 - val_sparse_categorical_accuracy: 0.6907 Epoch 58/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1175 - sparse_categorical_accuracy: 0.9573 - val_loss: 0.6089 - val_sparse_categorical_accuracy: 0.7212 Epoch 59/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1160 - sparse_categorical_accuracy: 0.9611 - val_loss: 0.1294 - val_sparse_categorical_accuracy: 0.9487 Epoch 60/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1096 - sparse_categorical_accuracy: 0.9642 - val_loss: 0.1527 - val_sparse_categorical_accuracy: 0.9417 Epoch 61/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1163 - sparse_categorical_accuracy: 0.9611 - val_loss: 0.5554 - val_sparse_categorical_accuracy: 0.7684 Epoch 62/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1090 - sparse_categorical_accuracy: 0.9656 - val_loss: 0.2433 - val_sparse_categorical_accuracy: 0.8904 Epoch 63/500 90/90 [==============================] - 0s 6ms/step - loss: 0.1105 - sparse_categorical_accuracy: 0.9656 - val_loss: 0.3426 - val_sparse_categorical_accuracy: 0.8571 Epoch 64/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1058 - sparse_categorical_accuracy: 0.9667 - val_loss: 2.1389 - val_sparse_categorical_accuracy: 0.5520 Epoch 65/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1037 - sparse_categorical_accuracy: 0.9674 - val_loss: 0.3875 - val_sparse_categorical_accuracy: 0.8738 Epoch 66/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1135 - sparse_categorical_accuracy: 0.9622 - val_loss: 0.1783 - val_sparse_categorical_accuracy: 0.9459 Epoch 67/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1006 - sparse_categorical_accuracy: 0.9681 - val_loss: 0.1462 - val_sparse_categorical_accuracy: 0.9515 Epoch 68/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0994 - sparse_categorical_accuracy: 0.9684 - val_loss: 0.1140 - val_sparse_categorical_accuracy: 0.9584 Epoch 69/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1095 - sparse_categorical_accuracy: 0.9635 - val_loss: 1.6500 - val_sparse_categorical_accuracy: 0.5589 Epoch 70/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1118 - sparse_categorical_accuracy: 0.9628 - val_loss: 1.3355 - val_sparse_categorical_accuracy: 0.6768 Epoch 71/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1155 - sparse_categorical_accuracy: 0.9608 - val_loss: 0.3167 - val_sparse_categorical_accuracy: 0.8793 Epoch 72/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1041 - sparse_categorical_accuracy: 0.9677 - val_loss: 0.1329 - val_sparse_categorical_accuracy: 0.9417 Epoch 73/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1001 - sparse_categorical_accuracy: 0.9677 - val_loss: 0.1385 - val_sparse_categorical_accuracy: 0.9417 Epoch 74/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0997 - sparse_categorical_accuracy: 0.9642 - val_loss: 0.1369 - val_sparse_categorical_accuracy: 0.9473 Epoch 75/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1051 - sparse_categorical_accuracy: 0.9667 - val_loss: 0.5135 - val_sparse_categorical_accuracy: 0.7781 Epoch 76/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0945 - sparse_categorical_accuracy: 0.9688 - val_loss: 0.1440 - val_sparse_categorical_accuracy: 0.9556 Epoch 77/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1081 - sparse_categorical_accuracy: 0.9618 - val_loss: 0.2210 - val_sparse_categorical_accuracy: 0.9196 Epoch 78/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1109 - sparse_categorical_accuracy: 0.9618 - val_loss: 0.2181 - val_sparse_categorical_accuracy: 0.9196 Epoch 79/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1047 - sparse_categorical_accuracy: 0.9608 - val_loss: 0.2074 - val_sparse_categorical_accuracy: 0.9237 Epoch 80/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1035 - sparse_categorical_accuracy: 0.9663 - val_loss: 0.3792 - val_sparse_categorical_accuracy: 0.8571 Epoch 81/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1040 - sparse_categorical_accuracy: 0.9674 - val_loss: 0.7353 - val_sparse_categorical_accuracy: 0.7420 Epoch 82/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1106 - sparse_categorical_accuracy: 0.9649 - val_loss: 0.2948 - val_sparse_categorical_accuracy: 0.9140 Epoch 83/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1066 - sparse_categorical_accuracy: 0.9656 - val_loss: 0.1338 - val_sparse_categorical_accuracy: 0.9570 Epoch 84/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0988 - sparse_categorical_accuracy: 0.9691 - val_loss: 0.1095 - val_sparse_categorical_accuracy: 0.9570 Epoch 85/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1065 - sparse_categorical_accuracy: 0.9622 - val_loss: 0.1717 - val_sparse_categorical_accuracy: 0.9417 Epoch 86/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1087 - sparse_categorical_accuracy: 0.9660 - val_loss: 0.1206 - val_sparse_categorical_accuracy: 0.9570 Epoch 87/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0991 - sparse_categorical_accuracy: 0.9656 - val_loss: 0.4285 - val_sparse_categorical_accuracy: 0.8474 Epoch 88/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0984 - sparse_categorical_accuracy: 0.9667 - val_loss: 0.1589 - val_sparse_categorical_accuracy: 0.9334 Epoch 89/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1023 - sparse_categorical_accuracy: 0.9701 - val_loss: 1.5442 - val_sparse_categorical_accuracy: 0.6782 Epoch 90/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0995 - sparse_categorical_accuracy: 0.9663 - val_loss: 0.1211 - val_sparse_categorical_accuracy: 0.9528 Epoch 91/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0908 - sparse_categorical_accuracy: 0.9705 - val_loss: 0.0987 - val_sparse_categorical_accuracy: 0.9556 Epoch 92/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0919 - sparse_categorical_accuracy: 0.9677 - val_loss: 0.2109 - val_sparse_categorical_accuracy: 0.9140 Epoch 93/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0890 - sparse_categorical_accuracy: 0.9715 - val_loss: 0.1509 - val_sparse_categorical_accuracy: 0.9431 Epoch 94/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0958 - sparse_categorical_accuracy: 0.9694 - val_loss: 0.1761 - val_sparse_categorical_accuracy: 0.9417 Epoch 95/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1000 - sparse_categorical_accuracy: 0.9663 - val_loss: 0.1466 - val_sparse_categorical_accuracy: 0.9293 Epoch 96/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0913 - sparse_categorical_accuracy: 0.9698 - val_loss: 0.6963 - val_sparse_categorical_accuracy: 0.7725 Epoch 97/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0954 - sparse_categorical_accuracy: 0.9667 - val_loss: 0.3042 - val_sparse_categorical_accuracy: 0.8738 Epoch 98/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0866 - sparse_categorical_accuracy: 0.9722 - val_loss: 0.1115 - val_sparse_categorical_accuracy: 0.9584 Epoch 99/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1017 - sparse_categorical_accuracy: 0.9615 - val_loss: 0.1195 - val_sparse_categorical_accuracy: 0.9584 Epoch 100/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1012 - sparse_categorical_accuracy: 0.9677 - val_loss: 0.1975 - val_sparse_categorical_accuracy: 0.9196 Epoch 101/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1058 - sparse_categorical_accuracy: 0.9622 - val_loss: 0.1960 - val_sparse_categorical_accuracy: 0.9487 Epoch 102/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0914 - sparse_categorical_accuracy: 0.9705 - val_loss: 0.1086 - val_sparse_categorical_accuracy: 0.9598 Epoch 103/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0907 - sparse_categorical_accuracy: 0.9701 - val_loss: 0.1117 - val_sparse_categorical_accuracy: 0.9584 Epoch 104/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0959 - sparse_categorical_accuracy: 0.9674 - val_loss: 3.9192 - val_sparse_categorical_accuracy: 0.4993 Epoch 105/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0991 - sparse_categorical_accuracy: 0.9632 - val_loss: 0.1232 - val_sparse_categorical_accuracy: 0.9473 Epoch 106/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0953 - sparse_categorical_accuracy: 0.9653 - val_loss: 0.1328 - val_sparse_categorical_accuracy: 0.9584 Epoch 107/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0835 - sparse_categorical_accuracy: 0.9750 - val_loss: 0.1480 - val_sparse_categorical_accuracy: 0.9542 Epoch 108/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0865 - sparse_categorical_accuracy: 0.9701 - val_loss: 0.1095 - val_sparse_categorical_accuracy: 0.9598 Epoch 109/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0940 - sparse_categorical_accuracy: 0.9681 - val_loss: 3.4316 - val_sparse_categorical_accuracy: 0.6422 Epoch 110/500 90/90 [==============================] - 1s 6ms/step - loss: 0.1015 - sparse_categorical_accuracy: 0.9632 - val_loss: 4.1126 - val_sparse_categorical_accuracy: 0.4965 Epoch 111/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0882 - sparse_categorical_accuracy: 0.9698 - val_loss: 0.1968 - val_sparse_categorical_accuracy: 0.9390 Epoch 112/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0778 - sparse_categorical_accuracy: 0.9764 - val_loss: 0.1051 - val_sparse_categorical_accuracy: 0.9584 Epoch 113/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0784 - sparse_categorical_accuracy: 0.9743 - val_loss: 0.1120 - val_sparse_categorical_accuracy: 0.9612 Epoch 114/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0765 - sparse_categorical_accuracy: 0.9792 - val_loss: 0.1347 - val_sparse_categorical_accuracy: 0.9556 Epoch 115/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0771 - sparse_categorical_accuracy: 0.9736 - val_loss: 0.1268 - val_sparse_categorical_accuracy: 0.9556 Epoch 116/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0787 - sparse_categorical_accuracy: 0.9743 - val_loss: 0.1014 - val_sparse_categorical_accuracy: 0.9626 Epoch 117/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0802 - sparse_categorical_accuracy: 0.9726 - val_loss: 0.0995 - val_sparse_categorical_accuracy: 0.9695 Epoch 118/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0770 - sparse_categorical_accuracy: 0.9774 - val_loss: 0.1022 - val_sparse_categorical_accuracy: 0.9598 Epoch 119/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0758 - sparse_categorical_accuracy: 0.9764 - val_loss: 0.2318 - val_sparse_categorical_accuracy: 0.9098 Epoch 120/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0751 - sparse_categorical_accuracy: 0.9750 - val_loss: 0.3361 - val_sparse_categorical_accuracy: 0.8793 Epoch 121/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0708 - sparse_categorical_accuracy: 0.9792 - val_loss: 0.1739 - val_sparse_categorical_accuracy: 0.9362 Epoch 122/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0764 - sparse_categorical_accuracy: 0.9753 - val_loss: 0.1351 - val_sparse_categorical_accuracy: 0.9556 Epoch 123/500 90/90 [==============================] - 0s 6ms/step - loss: 0.0724 - sparse_categorical_accuracy: 0.9750 - val_loss: 0.1064 - val_sparse_categorical_accuracy: 0.9556 Epoch 124/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0788 - sparse_categorical_accuracy: 0.9736 - val_loss: 0.1159 - val_sparse_categorical_accuracy: 0.9598 Epoch 125/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0806 - sparse_categorical_accuracy: 0.9719 - val_loss: 0.1268 - val_sparse_categorical_accuracy: 0.9612 Epoch 126/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0755 - sparse_categorical_accuracy: 0.9753 - val_loss: 0.1175 - val_sparse_categorical_accuracy: 0.9528 Epoch 127/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0741 - sparse_categorical_accuracy: 0.9757 - val_loss: 0.1049 - val_sparse_categorical_accuracy: 0.9612 Epoch 128/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0720 - sparse_categorical_accuracy: 0.9767 - val_loss: 0.1756 - val_sparse_categorical_accuracy: 0.9376 Epoch 129/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0734 - sparse_categorical_accuracy: 0.9757 - val_loss: 0.1165 - val_sparse_categorical_accuracy: 0.9639 Epoch 130/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0743 - sparse_categorical_accuracy: 0.9778 - val_loss: 0.1398 - val_sparse_categorical_accuracy: 0.9417 Epoch 131/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0764 - sparse_categorical_accuracy: 0.9726 - val_loss: 0.1193 - val_sparse_categorical_accuracy: 0.9459 Epoch 132/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0741 - sparse_categorical_accuracy: 0.9747 - val_loss: 0.1661 - val_sparse_categorical_accuracy: 0.9473 Epoch 133/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0677 - sparse_categorical_accuracy: 0.9792 - val_loss: 0.1016 - val_sparse_categorical_accuracy: 0.9612 Epoch 134/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0673 - sparse_categorical_accuracy: 0.9778 - val_loss: 0.1049 - val_sparse_categorical_accuracy: 0.9584 Epoch 135/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0681 - sparse_categorical_accuracy: 0.9802 - val_loss: 0.1109 - val_sparse_categorical_accuracy: 0.9515 Epoch 136/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0673 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.1198 - val_sparse_categorical_accuracy: 0.9542 Epoch 137/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0679 - sparse_categorical_accuracy: 0.9767 - val_loss: 0.1130 - val_sparse_categorical_accuracy: 0.9528 Epoch 138/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0717 - sparse_categorical_accuracy: 0.9774 - val_loss: 0.1009 - val_sparse_categorical_accuracy: 0.9612 Epoch 139/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0657 - sparse_categorical_accuracy: 0.9771 - val_loss: 0.1046 - val_sparse_categorical_accuracy: 0.9528 Epoch 140/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0711 - sparse_categorical_accuracy: 0.9767 - val_loss: 0.0977 - val_sparse_categorical_accuracy: 0.9639 Epoch 141/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0719 - sparse_categorical_accuracy: 0.9774 - val_loss: 0.1071 - val_sparse_categorical_accuracy: 0.9612 Epoch 142/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0663 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.1027 - val_sparse_categorical_accuracy: 0.9612 Epoch 143/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0699 - sparse_categorical_accuracy: 0.9781 - val_loss: 0.1131 - val_sparse_categorical_accuracy: 0.9626 Epoch 144/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0670 - sparse_categorical_accuracy: 0.9771 - val_loss: 0.1025 - val_sparse_categorical_accuracy: 0.9626 Epoch 145/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0653 - sparse_categorical_accuracy: 0.9785 - val_loss: 0.0935 - val_sparse_categorical_accuracy: 0.9653 Epoch 146/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0616 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.1075 - val_sparse_categorical_accuracy: 0.9556 Epoch 147/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0643 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0960 - val_sparse_categorical_accuracy: 0.9584 Epoch 148/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0681 - sparse_categorical_accuracy: 0.9792 - val_loss: 0.0944 - val_sparse_categorical_accuracy: 0.9639 Epoch 149/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0661 - sparse_categorical_accuracy: 0.9792 - val_loss: 0.1311 - val_sparse_categorical_accuracy: 0.9501 Epoch 150/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0693 - sparse_categorical_accuracy: 0.9781 - val_loss: 0.1715 - val_sparse_categorical_accuracy: 0.9390 Epoch 151/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0658 - sparse_categorical_accuracy: 0.9802 - val_loss: 0.1010 - val_sparse_categorical_accuracy: 0.9612 Epoch 152/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0652 - sparse_categorical_accuracy: 0.9778 - val_loss: 0.0949 - val_sparse_categorical_accuracy: 0.9639 Epoch 153/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0640 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.0996 - val_sparse_categorical_accuracy: 0.9598 Epoch 154/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0659 - sparse_categorical_accuracy: 0.9785 - val_loss: 0.0980 - val_sparse_categorical_accuracy: 0.9612 Epoch 155/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0666 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.1490 - val_sparse_categorical_accuracy: 0.9501 Epoch 156/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0659 - sparse_categorical_accuracy: 0.9774 - val_loss: 0.1010 - val_sparse_categorical_accuracy: 0.9570 Epoch 157/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0650 - sparse_categorical_accuracy: 0.9792 - val_loss: 0.1040 - val_sparse_categorical_accuracy: 0.9570 Epoch 158/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0626 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.0965 - val_sparse_categorical_accuracy: 0.9612 Epoch 159/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0645 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.1010 - val_sparse_categorical_accuracy: 0.9570 Epoch 160/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0691 - sparse_categorical_accuracy: 0.9774 - val_loss: 0.0987 - val_sparse_categorical_accuracy: 0.9626 Epoch 161/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0615 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0936 - val_sparse_categorical_accuracy: 0.9612 Epoch 162/500 90/90 [==============================] - 0s 6ms/step - loss: 0.0625 - sparse_categorical_accuracy: 0.9792 - val_loss: 0.1129 - val_sparse_categorical_accuracy: 0.9626 Epoch 163/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0601 - sparse_categorical_accuracy: 0.9802 - val_loss: 0.0989 - val_sparse_categorical_accuracy: 0.9584 Epoch 164/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0624 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.1512 - val_sparse_categorical_accuracy: 0.9515 Epoch 165/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0641 - sparse_categorical_accuracy: 0.9778 - val_loss: 0.0986 - val_sparse_categorical_accuracy: 0.9584 Epoch 166/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0558 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0979 - val_sparse_categorical_accuracy: 0.9598 Epoch 167/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0607 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.1085 - val_sparse_categorical_accuracy: 0.9626 Epoch 168/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0585 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.0976 - val_sparse_categorical_accuracy: 0.9639 Epoch 169/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0599 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.1078 - val_sparse_categorical_accuracy: 0.9626 Epoch 170/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0608 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.0951 - val_sparse_categorical_accuracy: 0.9626 Epoch 171/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0612 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.1004 - val_sparse_categorical_accuracy: 0.9612 Epoch 172/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0622 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0949 - val_sparse_categorical_accuracy: 0.9653 Epoch 173/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0622 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0923 - val_sparse_categorical_accuracy: 0.9639 Epoch 174/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0600 - sparse_categorical_accuracy: 0.9802 - val_loss: 0.1019 - val_sparse_categorical_accuracy: 0.9639 Epoch 175/500 90/90 [==============================] - 0s 6ms/step - loss: 0.0591 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.1238 - val_sparse_categorical_accuracy: 0.9626 Epoch 176/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0588 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0917 - val_sparse_categorical_accuracy: 0.9639 Epoch 177/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0598 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.1138 - val_sparse_categorical_accuracy: 0.9626 Epoch 178/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0566 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0938 - val_sparse_categorical_accuracy: 0.9639 Epoch 179/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0634 - sparse_categorical_accuracy: 0.9809 - val_loss: 0.0966 - val_sparse_categorical_accuracy: 0.9639 Epoch 180/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0579 - sparse_categorical_accuracy: 0.9830 - val_loss: 0.1033 - val_sparse_categorical_accuracy: 0.9653 Epoch 181/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0601 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0937 - val_sparse_categorical_accuracy: 0.9626 Epoch 182/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0545 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0979 - val_sparse_categorical_accuracy: 0.9626 Epoch 183/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0569 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0987 - val_sparse_categorical_accuracy: 0.9626 Epoch 184/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0569 - sparse_categorical_accuracy: 0.9854 - val_loss: 0.0907 - val_sparse_categorical_accuracy: 0.9626 Epoch 185/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0579 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0918 - val_sparse_categorical_accuracy: 0.9626 Epoch 186/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0571 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0933 - val_sparse_categorical_accuracy: 0.9626 Epoch 187/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0577 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0933 - val_sparse_categorical_accuracy: 0.9626 Epoch 188/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0634 - sparse_categorical_accuracy: 0.9809 - val_loss: 0.1014 - val_sparse_categorical_accuracy: 0.9667 Epoch 189/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0582 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0906 - val_sparse_categorical_accuracy: 0.9639 Epoch 190/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0571 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0931 - val_sparse_categorical_accuracy: 0.9626 Epoch 191/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0602 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.0903 - val_sparse_categorical_accuracy: 0.9626 Epoch 192/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0581 - sparse_categorical_accuracy: 0.9809 - val_loss: 0.0915 - val_sparse_categorical_accuracy: 0.9639 Epoch 193/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0574 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0914 - val_sparse_categorical_accuracy: 0.9639 Epoch 194/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0530 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0941 - val_sparse_categorical_accuracy: 0.9626 Epoch 195/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0557 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0925 - val_sparse_categorical_accuracy: 0.9653 Epoch 196/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0576 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.1018 - val_sparse_categorical_accuracy: 0.9639 Epoch 197/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0562 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.1003 - val_sparse_categorical_accuracy: 0.9626 Epoch 198/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0582 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0917 - val_sparse_categorical_accuracy: 0.9612 Epoch 199/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0602 - sparse_categorical_accuracy: 0.9809 - val_loss: 0.1001 - val_sparse_categorical_accuracy: 0.9667 Epoch 200/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0580 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.0927 - val_sparse_categorical_accuracy: 0.9584 Epoch 201/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0573 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.1226 - val_sparse_categorical_accuracy: 0.9612 Epoch 202/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0581 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0941 - val_sparse_categorical_accuracy: 0.9612 Epoch 203/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0602 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0933 - val_sparse_categorical_accuracy: 0.9639 Epoch 204/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0539 - sparse_categorical_accuracy: 0.9854 - val_loss: 0.0956 - val_sparse_categorical_accuracy: 0.9626 Epoch 205/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0561 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0947 - val_sparse_categorical_accuracy: 0.9639 Epoch 206/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0604 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.1132 - val_sparse_categorical_accuracy: 0.9639 Epoch 207/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0564 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0930 - val_sparse_categorical_accuracy: 0.9653 Epoch 208/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0615 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0941 - val_sparse_categorical_accuracy: 0.9626 Epoch 209/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0555 - sparse_categorical_accuracy: 0.9830 - val_loss: 0.0900 - val_sparse_categorical_accuracy: 0.9626 Epoch 210/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0589 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0936 - val_sparse_categorical_accuracy: 0.9612 Epoch 211/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0615 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0947 - val_sparse_categorical_accuracy: 0.9626 Epoch 212/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0599 - sparse_categorical_accuracy: 0.9799 - val_loss: 0.0943 - val_sparse_categorical_accuracy: 0.9612 Epoch 213/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0599 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9653 Epoch 214/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0548 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.1143 - val_sparse_categorical_accuracy: 0.9639 Epoch 215/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0526 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0965 - val_sparse_categorical_accuracy: 0.9626 Epoch 216/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0588 - sparse_categorical_accuracy: 0.9830 - val_loss: 0.0958 - val_sparse_categorical_accuracy: 0.9639 Epoch 217/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0549 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0942 - val_sparse_categorical_accuracy: 0.9612 Epoch 218/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0513 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.1027 - val_sparse_categorical_accuracy: 0.9612 Epoch 219/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0555 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.1217 - val_sparse_categorical_accuracy: 0.9598 Epoch 220/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0572 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.0933 - val_sparse_categorical_accuracy: 0.9653 Epoch 221/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0545 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0959 - val_sparse_categorical_accuracy: 0.9653 Epoch 222/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0545 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.1163 - val_sparse_categorical_accuracy: 0.9639 Epoch 223/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0556 - sparse_categorical_accuracy: 0.9830 - val_loss: 0.0955 - val_sparse_categorical_accuracy: 0.9626 Epoch 224/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0566 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.0931 - val_sparse_categorical_accuracy: 0.9598 Epoch 225/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0543 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0915 - val_sparse_categorical_accuracy: 0.9667 Epoch 226/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0566 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0931 - val_sparse_categorical_accuracy: 0.9626 Epoch 227/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0528 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0984 - val_sparse_categorical_accuracy: 0.9639 Epoch 228/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0576 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.1019 - val_sparse_categorical_accuracy: 0.9639 Epoch 229/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0572 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9639 Epoch 230/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0543 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0923 - val_sparse_categorical_accuracy: 0.9639 Epoch 231/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0566 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.0960 - val_sparse_categorical_accuracy: 0.9626 Epoch 232/500 90/90 [==============================] - 0s 6ms/step - loss: 0.0539 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0954 - val_sparse_categorical_accuracy: 0.9653 Epoch 233/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0536 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0965 - val_sparse_categorical_accuracy: 0.9626 Epoch 234/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0512 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0945 - val_sparse_categorical_accuracy: 0.9639 Epoch 235/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0528 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0925 - val_sparse_categorical_accuracy: 0.9639 Epoch 236/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0497 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0974 - val_sparse_categorical_accuracy: 0.9626 Epoch 237/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0529 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0957 - val_sparse_categorical_accuracy: 0.9612 Epoch 238/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0552 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0961 - val_sparse_categorical_accuracy: 0.9626 Epoch 239/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0573 - sparse_categorical_accuracy: 0.9830 - val_loss: 0.0943 - val_sparse_categorical_accuracy: 0.9598 Epoch 240/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0558 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.0935 - val_sparse_categorical_accuracy: 0.9639 Epoch 241/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0526 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0958 - val_sparse_categorical_accuracy: 0.9626 Epoch 242/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0488 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0976 - val_sparse_categorical_accuracy: 0.9626 Epoch 243/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0499 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0935 - val_sparse_categorical_accuracy: 0.9626 Epoch 244/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0505 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0945 - val_sparse_categorical_accuracy: 0.9639 Epoch 245/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0483 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0952 - val_sparse_categorical_accuracy: 0.9584 Epoch 246/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0524 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0958 - val_sparse_categorical_accuracy: 0.9653 Epoch 247/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0507 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0934 - val_sparse_categorical_accuracy: 0.9653 Epoch 248/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0553 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0946 - val_sparse_categorical_accuracy: 0.9598 Epoch 249/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0577 - sparse_categorical_accuracy: 0.9809 - val_loss: 0.0979 - val_sparse_categorical_accuracy: 0.9612 Epoch 250/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0535 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0979 - val_sparse_categorical_accuracy: 0.9626 Epoch 251/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0509 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0937 - val_sparse_categorical_accuracy: 0.9626 Epoch 252/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0571 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0937 - val_sparse_categorical_accuracy: 0.9612 Epoch 253/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0525 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.1017 - val_sparse_categorical_accuracy: 0.9639 Epoch 254/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0551 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0930 - val_sparse_categorical_accuracy: 0.9639 Epoch 255/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0557 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0896 - val_sparse_categorical_accuracy: 0.9653 Epoch 256/500 90/90 [==============================] - 0s 6ms/step - loss: 0.0494 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9612 Epoch 257/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0492 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0953 - val_sparse_categorical_accuracy: 0.9612 Epoch 258/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0525 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0923 - val_sparse_categorical_accuracy: 0.9626 Epoch 259/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0514 - sparse_categorical_accuracy: 0.9854 - val_loss: 0.0937 - val_sparse_categorical_accuracy: 0.9612 Epoch 260/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0511 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0934 - val_sparse_categorical_accuracy: 0.9612 Epoch 261/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0510 - sparse_categorical_accuracy: 0.9854 - val_loss: 0.0914 - val_sparse_categorical_accuracy: 0.9639 Epoch 262/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0498 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0957 - val_sparse_categorical_accuracy: 0.9653 Epoch 263/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0543 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.0956 - val_sparse_categorical_accuracy: 0.9653 Epoch 264/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0564 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.0917 - val_sparse_categorical_accuracy: 0.9598 Epoch 265/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0529 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0928 - val_sparse_categorical_accuracy: 0.9626 Epoch 266/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0564 - sparse_categorical_accuracy: 0.9816 - val_loss: 0.0978 - val_sparse_categorical_accuracy: 0.9639 Epoch 267/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0497 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0917 - val_sparse_categorical_accuracy: 0.9639 Epoch 268/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0538 - sparse_categorical_accuracy: 0.9795 - val_loss: 0.0913 - val_sparse_categorical_accuracy: 0.9626 Epoch 269/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0497 - sparse_categorical_accuracy: 0.9875 - val_loss: 0.0928 - val_sparse_categorical_accuracy: 0.9598 Epoch 270/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0553 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0950 - val_sparse_categorical_accuracy: 0.9626 Epoch 271/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0501 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0923 - val_sparse_categorical_accuracy: 0.9639 Epoch 272/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0575 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0903 - val_sparse_categorical_accuracy: 0.9639 Epoch 273/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0490 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.1155 - val_sparse_categorical_accuracy: 0.9626 Epoch 274/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0553 - sparse_categorical_accuracy: 0.9809 - val_loss: 0.0923 - val_sparse_categorical_accuracy: 0.9653 Epoch 275/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0513 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0915 - val_sparse_categorical_accuracy: 0.9598 Epoch 276/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0494 - sparse_categorical_accuracy: 0.9872 - val_loss: 0.0918 - val_sparse_categorical_accuracy: 0.9639 Epoch 277/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0606 - sparse_categorical_accuracy: 0.9819 - val_loss: 0.1049 - val_sparse_categorical_accuracy: 0.9639 Epoch 278/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0488 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0936 - val_sparse_categorical_accuracy: 0.9598 Epoch 279/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0535 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0934 - val_sparse_categorical_accuracy: 0.9639 Epoch 280/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0493 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0997 - val_sparse_categorical_accuracy: 0.9626 Epoch 281/500 90/90 [==============================] - 0s 5ms/step - loss: 0.0485 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0943 - val_sparse_categorical_accuracy: 0.9626 Epoch 282/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0493 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0906 - val_sparse_categorical_accuracy: 0.9626 Epoch 283/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0491 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0919 - val_sparse_categorical_accuracy: 0.9653 Epoch 284/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0482 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0895 - val_sparse_categorical_accuracy: 0.9639 Epoch 285/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0505 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0926 - val_sparse_categorical_accuracy: 0.9612 Epoch 286/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0466 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0950 - val_sparse_categorical_accuracy: 0.9639 Epoch 287/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0576 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0935 - val_sparse_categorical_accuracy: 0.9639 Epoch 288/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0527 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0943 - val_sparse_categorical_accuracy: 0.9639 Epoch 289/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0492 - sparse_categorical_accuracy: 0.9878 - val_loss: 0.0961 - val_sparse_categorical_accuracy: 0.9667 Epoch 290/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0466 - sparse_categorical_accuracy: 0.9882 - val_loss: 0.0947 - val_sparse_categorical_accuracy: 0.9612 Epoch 291/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0498 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0936 - val_sparse_categorical_accuracy: 0.9653 Epoch 292/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0489 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0922 - val_sparse_categorical_accuracy: 0.9653 Epoch 293/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0499 - sparse_categorical_accuracy: 0.9878 - val_loss: 0.0907 - val_sparse_categorical_accuracy: 0.9612 Epoch 294/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0511 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0892 - val_sparse_categorical_accuracy: 0.9639 Epoch 295/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0502 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0946 - val_sparse_categorical_accuracy: 0.9639 Epoch 296/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0504 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0902 - val_sparse_categorical_accuracy: 0.9639 Epoch 297/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0532 - sparse_categorical_accuracy: 0.9826 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9639 Epoch 298/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0526 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0950 - val_sparse_categorical_accuracy: 0.9584 Epoch 299/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0478 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.1001 - val_sparse_categorical_accuracy: 0.9612 Epoch 300/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0543 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.0929 - val_sparse_categorical_accuracy: 0.9639 Epoch 301/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0507 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0935 - val_sparse_categorical_accuracy: 0.9653 Epoch 302/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0512 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.0897 - val_sparse_categorical_accuracy: 0.9612 Epoch 303/500 90/90 [==============================] - 0s 5ms/step - loss: 0.0480 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.1003 - val_sparse_categorical_accuracy: 0.9612 Epoch 304/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0538 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0997 - val_sparse_categorical_accuracy: 0.9612 Epoch 305/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0528 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.1028 - val_sparse_categorical_accuracy: 0.9626 Epoch 306/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0507 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0949 - val_sparse_categorical_accuracy: 0.9612 Epoch 307/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0534 - sparse_categorical_accuracy: 0.9812 - val_loss: 0.0902 - val_sparse_categorical_accuracy: 0.9639 Epoch 308/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0497 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0929 - val_sparse_categorical_accuracy: 0.9681 Epoch 309/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0510 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0904 - val_sparse_categorical_accuracy: 0.9626 Epoch 310/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0518 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0967 - val_sparse_categorical_accuracy: 0.9598 Epoch 311/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0521 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0945 - val_sparse_categorical_accuracy: 0.9626 Epoch 312/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0586 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.0957 - val_sparse_categorical_accuracy: 0.9626 Epoch 313/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0470 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0984 - val_sparse_categorical_accuracy: 0.9598 Epoch 314/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0533 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9598 Epoch 315/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0502 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9639 Epoch 316/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0463 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0912 - val_sparse_categorical_accuracy: 0.9639 Epoch 317/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0515 - sparse_categorical_accuracy: 0.9830 - val_loss: 0.1047 - val_sparse_categorical_accuracy: 0.9626 Epoch 318/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0522 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0916 - val_sparse_categorical_accuracy: 0.9639 Epoch 319/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0494 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0919 - val_sparse_categorical_accuracy: 0.9639 Epoch 320/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0446 - sparse_categorical_accuracy: 0.9906 - val_loss: 0.0901 - val_sparse_categorical_accuracy: 0.9626 Epoch 321/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0527 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0910 - val_sparse_categorical_accuracy: 0.9598 Epoch 322/500 90/90 [==============================] - 0s 6ms/step - loss: 0.0476 - sparse_categorical_accuracy: 0.9872 - val_loss: 0.1029 - val_sparse_categorical_accuracy: 0.9598 Epoch 323/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0505 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0939 - val_sparse_categorical_accuracy: 0.9626 Epoch 324/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0505 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0900 - val_sparse_categorical_accuracy: 0.9612 Epoch 325/500 90/90 [==============================] - 0s 6ms/step - loss: 0.0516 - sparse_categorical_accuracy: 0.9854 - val_loss: 0.1024 - val_sparse_categorical_accuracy: 0.9626 Epoch 326/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0512 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0946 - val_sparse_categorical_accuracy: 0.9598 Epoch 327/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0509 - sparse_categorical_accuracy: 0.9872 - val_loss: 0.0988 - val_sparse_categorical_accuracy: 0.9626 Epoch 328/500 90/90 [==============================] - 0s 5ms/step - loss: 0.0427 - sparse_categorical_accuracy: 0.9889 - val_loss: 0.0913 - val_sparse_categorical_accuracy: 0.9639 Epoch 329/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0515 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0962 - val_sparse_categorical_accuracy: 0.9612 Epoch 330/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0477 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0917 - val_sparse_categorical_accuracy: 0.9598 Epoch 331/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0485 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0911 - val_sparse_categorical_accuracy: 0.9626 Epoch 332/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0479 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0999 - val_sparse_categorical_accuracy: 0.9612 Epoch 333/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0465 - sparse_categorical_accuracy: 0.9872 - val_loss: 0.0877 - val_sparse_categorical_accuracy: 0.9639 Epoch 334/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0500 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.1073 - val_sparse_categorical_accuracy: 0.9626 Epoch 335/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0506 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0913 - val_sparse_categorical_accuracy: 0.9612 Epoch 336/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0473 - sparse_categorical_accuracy: 0.9872 - val_loss: 0.1075 - val_sparse_categorical_accuracy: 0.9639 Epoch 337/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0494 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0953 - val_sparse_categorical_accuracy: 0.9626 Epoch 338/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0510 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0904 - val_sparse_categorical_accuracy: 0.9639 Epoch 339/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0521 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0913 - val_sparse_categorical_accuracy: 0.9584 Epoch 340/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0512 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9626 Epoch 341/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0468 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0990 - val_sparse_categorical_accuracy: 0.9626 Epoch 342/500 90/90 [==============================] - 0s 5ms/step - loss: 0.0494 - sparse_categorical_accuracy: 0.9875 - val_loss: 0.0950 - val_sparse_categorical_accuracy: 0.9653 Epoch 343/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0518 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0937 - val_sparse_categorical_accuracy: 0.9598 Epoch 344/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0488 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0958 - val_sparse_categorical_accuracy: 0.9639 Epoch 345/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0523 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.1467 - val_sparse_categorical_accuracy: 0.9515 Epoch 346/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0482 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0917 - val_sparse_categorical_accuracy: 0.9667 Epoch 347/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0492 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.1134 - val_sparse_categorical_accuracy: 0.9626 Epoch 348/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0455 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0976 - val_sparse_categorical_accuracy: 0.9612 Epoch 349/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0462 - sparse_categorical_accuracy: 0.9896 - val_loss: 0.0898 - val_sparse_categorical_accuracy: 0.9667 Epoch 350/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0497 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0912 - val_sparse_categorical_accuracy: 0.9639 Epoch 351/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0462 - sparse_categorical_accuracy: 0.9889 - val_loss: 0.0932 - val_sparse_categorical_accuracy: 0.9626 Epoch 352/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0515 - sparse_categorical_accuracy: 0.9823 - val_loss: 0.0913 - val_sparse_categorical_accuracy: 0.9653 Epoch 353/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0455 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0945 - val_sparse_categorical_accuracy: 0.9612 Epoch 354/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0452 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0921 - val_sparse_categorical_accuracy: 0.9598 Epoch 355/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0430 - sparse_categorical_accuracy: 0.9861 - val_loss: 0.0903 - val_sparse_categorical_accuracy: 0.9626 Epoch 356/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0471 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.1045 - val_sparse_categorical_accuracy: 0.9626 Epoch 357/500 90/90 [==============================] - 0s 5ms/step - loss: 0.0508 - sparse_categorical_accuracy: 0.9847 - val_loss: 0.0949 - val_sparse_categorical_accuracy: 0.9653 Epoch 358/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0468 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0931 - val_sparse_categorical_accuracy: 0.9639 Epoch 359/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0466 - sparse_categorical_accuracy: 0.9851 - val_loss: 0.0913 - val_sparse_categorical_accuracy: 0.9612 Epoch 360/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0440 - sparse_categorical_accuracy: 0.9899 - val_loss: 0.0988 - val_sparse_categorical_accuracy: 0.9626 Epoch 361/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0448 - sparse_categorical_accuracy: 0.9875 - val_loss: 0.0975 - val_sparse_categorical_accuracy: 0.9667 Epoch 362/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0477 - sparse_categorical_accuracy: 0.9875 - val_loss: 0.0914 - val_sparse_categorical_accuracy: 0.9639 Epoch 363/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0493 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0906 - val_sparse_categorical_accuracy: 0.9626 Epoch 364/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0488 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0931 - val_sparse_categorical_accuracy: 0.9626 Epoch 365/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0491 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.0960 - val_sparse_categorical_accuracy: 0.9626 Epoch 366/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0477 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0891 - val_sparse_categorical_accuracy: 0.9612 Epoch 367/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0470 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.1026 - val_sparse_categorical_accuracy: 0.9626 Epoch 368/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0463 - sparse_categorical_accuracy: 0.9885 - val_loss: 0.0909 - val_sparse_categorical_accuracy: 0.9626 Epoch 369/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0459 - sparse_categorical_accuracy: 0.9865 - val_loss: 0.0909 - val_sparse_categorical_accuracy: 0.9639 Epoch 370/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0511 - sparse_categorical_accuracy: 0.9868 - val_loss: 0.1036 - val_sparse_categorical_accuracy: 0.9626 Epoch 371/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0479 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0922 - val_sparse_categorical_accuracy: 0.9626 Epoch 372/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0516 - sparse_categorical_accuracy: 0.9840 - val_loss: 0.0932 - val_sparse_categorical_accuracy: 0.9653 Epoch 373/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0451 - sparse_categorical_accuracy: 0.9858 - val_loss: 0.0928 - val_sparse_categorical_accuracy: 0.9639 Epoch 374/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0461 - sparse_categorical_accuracy: 0.9854 - val_loss: 0.0911 - val_sparse_categorical_accuracy: 0.9612 Epoch 375/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0494 - sparse_categorical_accuracy: 0.9833 - val_loss: 0.0895 - val_sparse_categorical_accuracy: 0.9639 Epoch 376/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0466 - sparse_categorical_accuracy: 0.9830 - val_loss: 0.0902 - val_sparse_categorical_accuracy: 0.9639 Epoch 377/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0465 - sparse_categorical_accuracy: 0.9844 - val_loss: 0.0908 - val_sparse_categorical_accuracy: 0.9681 Epoch 378/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0430 - sparse_categorical_accuracy: 0.9882 - val_loss: 0.0906 - val_sparse_categorical_accuracy: 0.9626 Epoch 379/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0524 - sparse_categorical_accuracy: 0.9837 - val_loss: 0.0910 - val_sparse_categorical_accuracy: 0.9598 Epoch 380/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0467 - sparse_categorical_accuracy: 0.9872 - val_loss: 0.0947 - val_sparse_categorical_accuracy: 0.9639 Epoch 381/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0464 - sparse_categorical_accuracy: 0.9885 - val_loss: 0.0922 - val_sparse_categorical_accuracy: 0.9653 Epoch 382/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0449 - sparse_categorical_accuracy: 0.9885 - val_loss: 0.0918 - val_sparse_categorical_accuracy: 0.9639 Epoch 383/500 90/90 [==============================] - 1s 6ms/step - loss: 0.0438 - sparse_categorical_accuracy: 0.9889 - val_loss: 0.0905 - val_sparse_categorical_accuracy: 0.9612 Epoch 00383: early stopping Evaluate model on test data model = keras.models.load_model(\"best_model.h5\") test_loss, test_acc = model.evaluate(x_test, y_test) print(\"Test accuracy\", test_acc) print(\"Test loss\", test_loss) 42/42 [==============================] - 0s 2ms/step - loss: 0.0936 - sparse_categorical_accuracy: 0.9682 Test accuracy 0.9681817889213562 Test loss 0.0935916006565094 Plot the model's training and validation loss metric = \"sparse_categorical_accuracy\" plt.figure() plt.plot(history.history[metric]) plt.plot(history.history[\"val_\" + metric]) plt.title(\"model \" + metric) plt.ylabel(metric, fontsize=\"large\") plt.xlabel(\"epoch\", fontsize=\"large\") plt.legend([\"train\", \"val\"], loc=\"best\") plt.show() plt.close() png We can see how the training accuracy reaches almost 0.95 after 100 epochs. However, by observing the validation accuracy we can see how the network still needs training until it reaches almost 0.97 for both the validation and the training accuracy after 200 epochs. Beyond the 200th epoch, if we continue on training, the validation accuracy will start decreasing while the training accuracy will continue on increasing: the model starts overfitting. This notebook demonstrates how to do timeseries classification using a Transformer model. Introduction This is the Transformer architecture from Attention Is All You Need, applied to timeseries instead of natural language. This example requires TensorFlow 2.4 or higher. Load the dataset We are going to use the same dataset and preprocessing as the TimeSeries Classification from Scratch example. import numpy as np def readucr(filename): data = np.loadtxt(filename, delimiter=\"\t\") y = data[:, 0] x = data[:, 1:] return x, y.astype(int) root_url = \"https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/\" x_train, y_train = readucr(root_url + \"FordA_TRAIN.tsv\") x_test, y_test = readucr(root_url + \"FordA_TEST.tsv\") x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], 1)) x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], 1)) n_classes = len(np.unique(y_train)) idx = np.random.permutation(len(x_train)) x_train = x_train[idx] y_train = y_train[idx] y_train[y_train == -1] = 0 y_test[y_test == -1] = 0 Build the model Our model processes a tensor of shape (batch size, sequence length, features), where sequence length is the number of time steps and features is each input timeseries. You can replace your classification RNN layers with this one: the inputs are fully compatible! from tensorflow import keras from tensorflow.keras import layers We include residual connections, layer normalization, and dropout. The resulting layer can be stacked multiple times. The projection layers are implemented through keras.layers.Conv1D. def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0): # Attention and Normalization x = layers.MultiHeadAttention( key_dim=head_size, num_heads=num_heads, dropout=dropout )(inputs, inputs) x = layers.Dropout(dropout)(x) x = layers.LayerNormalization(epsilon=1e-6)(x) res = x + inputs # Feed Forward Part x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation=\"relu\")(res) x = layers.Dropout(dropout)(x) x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x) x = layers.LayerNormalization(epsilon=1e-6)(x) return x + res The main part of our model is now complete. We can stack multiple of those transformer_encoder blocks and we can also proceed to add the final Multi-Layer Perceptron classification head. Apart from a stack of Dense layers, we need to reduce the output tensor of the TransformerEncoder part of our model down to a vector of features for each data point in the current batch. A common way to achieve this is to use a pooling layer. For this example, a GlobalAveragePooling1D layer is sufficient. def build_model( input_shape, head_size, num_heads, ff_dim, num_transformer_blocks, mlp_units, dropout=0, mlp_dropout=0, ): inputs = keras.Input(shape=input_shape) x = inputs for _ in range(num_transformer_blocks): x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout) x = layers.GlobalAveragePooling1D(data_format=\"channels_first\")(x) for dim in mlp_units: x = layers.Dense(dim, activation=\"relu\")(x) x = layers.Dropout(mlp_dropout)(x) outputs = layers.Dense(n_classes, activation=\"softmax\")(x) return keras.Model(inputs, outputs) Train and evaluate input_shape = x_train.shape[1:] model = build_model( input_shape, head_size=256, num_heads=4, ff_dim=4, num_transformer_blocks=4, mlp_units=[128], mlp_dropout=0.4, dropout=0.25, ) model.compile( loss=\"sparse_categorical_crossentropy\", optimizer=keras.optimizers.Adam(learning_rate=1e-4), metrics=[\"sparse_categorical_accuracy\"], ) model.summary() callbacks = [keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)] model.fit( x_train, y_train, validation_split=0.2, epochs=200, batch_size=64, callbacks=callbacks, ) model.evaluate(x_test, y_test, verbose=1) Model: \"model\" __________________________________________________________________________________________________ Layer (type) Output Shape Param # Connected to ================================================================================================== input_1 (InputLayer) [(None, 500, 1)] 0 __________________________________________________________________________________________________ layer_normalization (LayerNorma (None, 500, 1) 2 input_1[0][0] __________________________________________________________________________________________________ multi_head_attention (MultiHead (None, 500, 1) 7169 layer_normalization[0][0] layer_normalization[0][0] __________________________________________________________________________________________________ dropout (Dropout) (None, 500, 1) 0 multi_head_attention[0][0] __________________________________________________________________________________________________ tf.__operators__.add (TFOpLambd (None, 500, 1) 0 dropout[0][0] input_1[0][0] __________________________________________________________________________________________________ layer_normalization_1 (LayerNor (None, 500, 1) 2 tf.__operators__.add[0][0] __________________________________________________________________________________________________ conv1d (Conv1D) (None, 500, 4) 8 layer_normalization_1[0][0] __________________________________________________________________________________________________ dropout_1 (Dropout) (None, 500, 4) 0 conv1d[0][0] __________________________________________________________________________________________________ conv1d_1 (Conv1D) (None, 500, 1) 5 dropout_1[0][0] __________________________________________________________________________________________________ tf.__operators__.add_1 (TFOpLam (None, 500, 1) 0 conv1d_1[0][0] tf.__operators__.add[0][0] __________________________________________________________________________________________________ layer_normalization_2 (LayerNor (None, 500, 1) 2 tf.__operators__.add_1[0][0] __________________________________________________________________________________________________ multi_head_attention_1 (MultiHe (None, 500, 1) 7169 layer_normalization_2[0][0] layer_normalization_2[0][0] __________________________________________________________________________________________________ dropout_2 (Dropout) (None, 500, 1) 0 multi_head_attention_1[0][0] __________________________________________________________________________________________________ tf.__operators__.add_2 (TFOpLam (None, 500, 1) 0 dropout_2[0][0] tf.__operators__.add_1[0][0] __________________________________________________________________________________________________ layer_normalization_3 (LayerNor (None, 500, 1) 2 tf.__operators__.add_2[0][0] __________________________________________________________________________________________________ conv1d_2 (Conv1D) (None, 500, 4) 8 layer_normalization_3[0][0] __________________________________________________________________________________________________ dropout_3 (Dropout) (None, 500, 4) 0 conv1d_2[0][0] __________________________________________________________________________________________________ conv1d_3 (Conv1D) (None, 500, 1) 5 dropout_3[0][0] __________________________________________________________________________________________________ tf.__operators__.add_3 (TFOpLam (None, 500, 1) 0 conv1d_3[0][0] tf.__operators__.add_2[0][0] __________________________________________________________________________________________________ layer_normalization_4 (LayerNor (None, 500, 1) 2 tf.__operators__.add_3[0][0] __________________________________________________________________________________________________ multi_head_attention_2 (MultiHe (None, 500, 1) 7169 layer_normalization_4[0][0] layer_normalization_4[0][0] __________________________________________________________________________________________________ dropout_4 (Dropout) (None, 500, 1) 0 multi_head_attention_2[0][0] __________________________________________________________________________________________________ tf.__operators__.add_4 (TFOpLam (None, 500, 1) 0 dropout_4[0][0] tf.__operators__.add_3[0][0] __________________________________________________________________________________________________ layer_normalization_5 (LayerNor (None, 500, 1) 2 tf.__operators__.add_4[0][0] __________________________________________________________________________________________________ conv1d_4 (Conv1D) (None, 500, 4) 8 layer_normalization_5[0][0] __________________________________________________________________________________________________ dropout_5 (Dropout) (None, 500, 4) 0 conv1d_4[0][0] __________________________________________________________________________________________________ conv1d_5 (Conv1D) (None, 500, 1) 5 dropout_5[0][0] __________________________________________________________________________________________________ tf.__operators__.add_5 (TFOpLam (None, 500, 1) 0 conv1d_5[0][0] tf.__operators__.add_4[0][0] __________________________________________________________________________________________________ layer_normalization_6 (LayerNor (None, 500, 1) 2 tf.__operators__.add_5[0][0] __________________________________________________________________________________________________ multi_head_attention_3 (MultiHe (None, 500, 1) 7169 layer_normalization_6[0][0] layer_normalization_6[0][0] __________________________________________________________________________________________________ dropout_6 (Dropout) (None, 500, 1) 0 multi_head_attention_3[0][0] __________________________________________________________________________________________________ tf.__operators__.add_6 (TFOpLam (None, 500, 1) 0 dropout_6[0][0] tf.__operators__.add_5[0][0] __________________________________________________________________________________________________ layer_normalization_7 (LayerNor (None, 500, 1) 2 tf.__operators__.add_6[0][0] __________________________________________________________________________________________________ conv1d_6 (Conv1D) (None, 500, 4) 8 layer_normalization_7[0][0] __________________________________________________________________________________________________ dropout_7 (Dropout) (None, 500, 4) 0 conv1d_6[0][0] __________________________________________________________________________________________________ conv1d_7 (Conv1D) (None, 500, 1) 5 dropout_7[0][0] __________________________________________________________________________________________________ tf.__operators__.add_7 (TFOpLam (None, 500, 1) 0 conv1d_7[0][0] tf.__operators__.add_6[0][0] __________________________________________________________________________________________________ global_average_pooling1d (Globa (None, 500) 0 tf.__operators__.add_7[0][0] __________________________________________________________________________________________________ dense (Dense) (None, 128) 64128 global_average_pooling1d[0][0] __________________________________________________________________________________________________ dropout_8 (Dropout) (None, 128) 0 dense[0][0] __________________________________________________________________________________________________ dense_1 (Dense) (None, 2) 258 dropout_8[0][0] ================================================================================================== Total params: 93,130 Trainable params: 93,130 Non-trainable params: 0 __________________________________________________________________________________________________ Epoch 1/200 45/45 [==============================] - 26s 499ms/step - loss: 1.0233 - sparse_categorical_accuracy: 0.5174 - val_loss: 0.7853 - val_sparse_categorical_accuracy: 0.5368 Epoch 2/200 45/45 [==============================] - 22s 499ms/step - loss: 0.9108 - sparse_categorical_accuracy: 0.5507 - val_loss: 0.7169 - val_sparse_categorical_accuracy: 0.5659 Epoch 3/200 45/45 [==============================] - 23s 509ms/step - loss: 0.8177 - sparse_categorical_accuracy: 0.5851 - val_loss: 0.6851 - val_sparse_categorical_accuracy: 0.5839 Epoch 4/200 45/45 [==============================] - 24s 532ms/step - loss: 0.7494 - sparse_categorical_accuracy: 0.6160 - val_loss: 0.6554 - val_sparse_categorical_accuracy: 0.6214 Epoch 5/200 45/45 [==============================] - 23s 520ms/step - loss: 0.7287 - sparse_categorical_accuracy: 0.6319 - val_loss: 0.6333 - val_sparse_categorical_accuracy: 0.6463 Epoch 6/200 45/45 [==============================] - 23s 509ms/step - loss: 0.7108 - sparse_categorical_accuracy: 0.6424 - val_loss: 0.6185 - val_sparse_categorical_accuracy: 0.6546 Epoch 7/200 45/45 [==============================] - 23s 512ms/step - loss: 0.6624 - sparse_categorical_accuracy: 0.6667 - val_loss: 0.6023 - val_sparse_categorical_accuracy: 0.6657 Epoch 8/200 45/45 [==============================] - 23s 518ms/step - loss: 0.6392 - sparse_categorical_accuracy: 0.6774 - val_loss: 0.5935 - val_sparse_categorical_accuracy: 0.6796 Epoch 9/200 45/45 [==============================] - 23s 513ms/step - loss: 0.5978 - sparse_categorical_accuracy: 0.6955 - val_loss: 0.5778 - val_sparse_categorical_accuracy: 0.6907 Epoch 10/200 45/45 [==============================] - 23s 511ms/step - loss: 0.5909 - sparse_categorical_accuracy: 0.6948 - val_loss: 0.5687 - val_sparse_categorical_accuracy: 0.6935 Epoch 11/200 45/45 [==============================] - 23s 513ms/step - loss: 0.5785 - sparse_categorical_accuracy: 0.7021 - val_loss: 0.5628 - val_sparse_categorical_accuracy: 0.6990 Epoch 12/200 45/45 [==============================] - 23s 514ms/step - loss: 0.5547 - sparse_categorical_accuracy: 0.7247 - val_loss: 0.5545 - val_sparse_categorical_accuracy: 0.7101 Epoch 13/200 45/45 [==============================] - 24s 535ms/step - loss: 0.5705 - sparse_categorical_accuracy: 0.7240 - val_loss: 0.5461 - val_sparse_categorical_accuracy: 0.7240 Epoch 14/200 45/45 [==============================] - 23s 517ms/step - loss: 0.5538 - sparse_categorical_accuracy: 0.7250 - val_loss: 0.5403 - val_sparse_categorical_accuracy: 0.7212 Epoch 15/200 45/45 [==============================] - 23s 515ms/step - loss: 0.5144 - sparse_categorical_accuracy: 0.7500 - val_loss: 0.5318 - val_sparse_categorical_accuracy: 0.7295 Epoch 16/200 45/45 [==============================] - 23s 512ms/step - loss: 0.5200 - sparse_categorical_accuracy: 0.7521 - val_loss: 0.5286 - val_sparse_categorical_accuracy: 0.7379 Epoch 17/200 45/45 [==============================] - 23s 515ms/step - loss: 0.4910 - sparse_categorical_accuracy: 0.7590 - val_loss: 0.5229 - val_sparse_categorical_accuracy: 0.7393 Epoch 18/200 45/45 [==============================] - 23s 514ms/step - loss: 0.5013 - sparse_categorical_accuracy: 0.7427 - val_loss: 0.5157 - val_sparse_categorical_accuracy: 0.7462 Epoch 19/200 45/45 [==============================] - 23s 511ms/step - loss: 0.4883 - sparse_categorical_accuracy: 0.7712 - val_loss: 0.5123 - val_sparse_categorical_accuracy: 0.7490 Epoch 20/200 45/45 [==============================] - 23s 514ms/step - loss: 0.4935 - sparse_categorical_accuracy: 0.7667 - val_loss: 0.5032 - val_sparse_categorical_accuracy: 0.7545 Epoch 21/200 45/45 [==============================] - 23s 514ms/step - loss: 0.4551 - sparse_categorical_accuracy: 0.7799 - val_loss: 0.4978 - val_sparse_categorical_accuracy: 0.7573 Epoch 22/200 45/45 [==============================] - 23s 516ms/step - loss: 0.4477 - sparse_categorical_accuracy: 0.7948 - val_loss: 0.4941 - val_sparse_categorical_accuracy: 0.7531 Epoch 23/200 45/45 [==============================] - 23s 518ms/step - loss: 0.4549 - sparse_categorical_accuracy: 0.7858 - val_loss: 0.4893 - val_sparse_categorical_accuracy: 0.7656 Epoch 24/200 45/45 [==============================] - 23s 516ms/step - loss: 0.4426 - sparse_categorical_accuracy: 0.7948 - val_loss: 0.4842 - val_sparse_categorical_accuracy: 0.7712 Epoch 25/200 45/45 [==============================] - 23s 520ms/step - loss: 0.4360 - sparse_categorical_accuracy: 0.8035 - val_loss: 0.4798 - val_sparse_categorical_accuracy: 0.7809 Epoch 26/200 45/45 [==============================] - 23s 515ms/step - loss: 0.4316 - sparse_categorical_accuracy: 0.8035 - val_loss: 0.4715 - val_sparse_categorical_accuracy: 0.7809 Epoch 27/200 45/45 [==============================] - 23s 518ms/step - loss: 0.4084 - sparse_categorical_accuracy: 0.8146 - val_loss: 0.4676 - val_sparse_categorical_accuracy: 0.7878 Epoch 28/200 45/45 [==============================] - 23s 515ms/step - loss: 0.3998 - sparse_categorical_accuracy: 0.8240 - val_loss: 0.4667 - val_sparse_categorical_accuracy: 0.7933 Epoch 29/200 45/45 [==============================] - 23s 514ms/step - loss: 0.3993 - sparse_categorical_accuracy: 0.8198 - val_loss: 0.4603 - val_sparse_categorical_accuracy: 0.7892 Epoch 30/200 45/45 [==============================] - 23s 515ms/step - loss: 0.4031 - sparse_categorical_accuracy: 0.8243 - val_loss: 0.4562 - val_sparse_categorical_accuracy: 0.7920 Epoch 31/200 45/45 [==============================] - 23s 511ms/step - loss: 0.3891 - sparse_categorical_accuracy: 0.8184 - val_loss: 0.4528 - val_sparse_categorical_accuracy: 0.7920 Epoch 32/200 45/45 [==============================] - 23s 516ms/step - loss: 0.3922 - sparse_categorical_accuracy: 0.8292 - val_loss: 0.4485 - val_sparse_categorical_accuracy: 0.7892 Epoch 33/200 45/45 [==============================] - 23s 516ms/step - loss: 0.3802 - sparse_categorical_accuracy: 0.8309 - val_loss: 0.4463 - val_sparse_categorical_accuracy: 0.8003 Epoch 34/200 45/45 [==============================] - 23s 514ms/step - loss: 0.3711 - sparse_categorical_accuracy: 0.8372 - val_loss: 0.4427 - val_sparse_categorical_accuracy: 0.7975 Epoch 35/200 45/45 [==============================] - 23s 512ms/step - loss: 0.3744 - sparse_categorical_accuracy: 0.8378 - val_loss: 0.4366 - val_sparse_categorical_accuracy: 0.8072 Epoch 36/200 45/45 [==============================] - 23s 511ms/step - loss: 0.3653 - sparse_categorical_accuracy: 0.8372 - val_loss: 0.4338 - val_sparse_categorical_accuracy: 0.8072 Epoch 37/200 45/45 [==============================] - 23s 512ms/step - loss: 0.3681 - sparse_categorical_accuracy: 0.8382 - val_loss: 0.4337 - val_sparse_categorical_accuracy: 0.8058 Epoch 38/200 45/45 [==============================] - 23s 512ms/step - loss: 0.3634 - sparse_categorical_accuracy: 0.8514 - val_loss: 0.4264 - val_sparse_categorical_accuracy: 0.8128 Epoch 39/200 45/45 [==============================] - 23s 512ms/step - loss: 0.3498 - sparse_categorical_accuracy: 0.8535 - val_loss: 0.4211 - val_sparse_categorical_accuracy: 0.8225 Epoch 40/200 45/45 [==============================] - 23s 514ms/step - loss: 0.3358 - sparse_categorical_accuracy: 0.8663 - val_loss: 0.4161 - val_sparse_categorical_accuracy: 0.8197 Epoch 41/200 45/45 [==============================] - 23s 512ms/step - loss: 0.3448 - sparse_categorical_accuracy: 0.8573 - val_loss: 0.4161 - val_sparse_categorical_accuracy: 0.8169 Epoch 42/200 45/45 [==============================] - 23s 512ms/step - loss: 0.3439 - sparse_categorical_accuracy: 0.8552 - val_loss: 0.4119 - val_sparse_categorical_accuracy: 0.8211 Epoch 43/200 45/45 [==============================] - 23s 510ms/step - loss: 0.3335 - sparse_categorical_accuracy: 0.8660 - val_loss: 0.4101 - val_sparse_categorical_accuracy: 0.8266 Epoch 44/200 45/45 [==============================] - 23s 510ms/step - loss: 0.3235 - sparse_categorical_accuracy: 0.8660 - val_loss: 0.4067 - val_sparse_categorical_accuracy: 0.8294 Epoch 45/200 45/45 [==============================] - 23s 510ms/step - loss: 0.3273 - sparse_categorical_accuracy: 0.8656 - val_loss: 0.4033 - val_sparse_categorical_accuracy: 0.8350 Epoch 46/200 45/45 [==============================] - 23s 513ms/step - loss: 0.3277 - sparse_categorical_accuracy: 0.8608 - val_loss: 0.3994 - val_sparse_categorical_accuracy: 0.8336 Epoch 47/200 45/45 [==============================] - 23s 519ms/step - loss: 0.3136 - sparse_categorical_accuracy: 0.8708 - val_loss: 0.3945 - val_sparse_categorical_accuracy: 0.8363 Epoch 48/200 45/45 [==============================] - 23s 518ms/step - loss: 0.3122 - sparse_categorical_accuracy: 0.8764 - val_loss: 0.3925 - val_sparse_categorical_accuracy: 0.8350 Epoch 49/200 45/45 [==============================] - 23s 519ms/step - loss: 0.3035 - sparse_categorical_accuracy: 0.8826 - val_loss: 0.3906 - val_sparse_categorical_accuracy: 0.8308 Epoch 50/200 45/45 [==============================] - 23s 512ms/step - loss: 0.2994 - sparse_categorical_accuracy: 0.8823 - val_loss: 0.3888 - val_sparse_categorical_accuracy: 0.8377 Epoch 51/200 45/45 [==============================] - 23s 514ms/step - loss: 0.3023 - sparse_categorical_accuracy: 0.8781 - val_loss: 0.3862 - val_sparse_categorical_accuracy: 0.8391 Epoch 52/200 45/45 [==============================] - 23s 515ms/step - loss: 0.3012 - sparse_categorical_accuracy: 0.8833 - val_loss: 0.3854 - val_sparse_categorical_accuracy: 0.8350 Epoch 53/200 45/45 [==============================] - 23s 513ms/step - loss: 0.2890 - sparse_categorical_accuracy: 0.8837 - val_loss: 0.3837 - val_sparse_categorical_accuracy: 0.8363 Epoch 54/200 45/45 [==============================] - 23s 513ms/step - loss: 0.2931 - sparse_categorical_accuracy: 0.8858 - val_loss: 0.3809 - val_sparse_categorical_accuracy: 0.8433 Epoch 55/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2867 - sparse_categorical_accuracy: 0.8885 - val_loss: 0.3784 - val_sparse_categorical_accuracy: 0.8447 Epoch 56/200 45/45 [==============================] - 23s 511ms/step - loss: 0.2731 - sparse_categorical_accuracy: 0.8986 - val_loss: 0.3756 - val_sparse_categorical_accuracy: 0.8488 Epoch 57/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2754 - sparse_categorical_accuracy: 0.8955 - val_loss: 0.3759 - val_sparse_categorical_accuracy: 0.8474 Epoch 58/200 45/45 [==============================] - 23s 511ms/step - loss: 0.2775 - sparse_categorical_accuracy: 0.8976 - val_loss: 0.3704 - val_sparse_categorical_accuracy: 0.8474 Epoch 59/200 45/45 [==============================] - 23s 513ms/step - loss: 0.2770 - sparse_categorical_accuracy: 0.9000 - val_loss: 0.3698 - val_sparse_categorical_accuracy: 0.8558 Epoch 60/200 45/45 [==============================] - 23s 516ms/step - loss: 0.2688 - sparse_categorical_accuracy: 0.8965 - val_loss: 0.3697 - val_sparse_categorical_accuracy: 0.8502 Epoch 61/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2716 - sparse_categorical_accuracy: 0.8972 - val_loss: 0.3710 - val_sparse_categorical_accuracy: 0.8405 Epoch 62/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2635 - sparse_categorical_accuracy: 0.9087 - val_loss: 0.3656 - val_sparse_categorical_accuracy: 0.8488 Epoch 63/200 45/45 [==============================] - 23s 520ms/step - loss: 0.2596 - sparse_categorical_accuracy: 0.8979 - val_loss: 0.3654 - val_sparse_categorical_accuracy: 0.8488 Epoch 64/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2586 - sparse_categorical_accuracy: 0.9062 - val_loss: 0.3634 - val_sparse_categorical_accuracy: 0.8530 Epoch 65/200 45/45 [==============================] - 23s 516ms/step - loss: 0.2491 - sparse_categorical_accuracy: 0.9139 - val_loss: 0.3591 - val_sparse_categorical_accuracy: 0.8530 Epoch 66/200 45/45 [==============================] - 23s 519ms/step - loss: 0.2600 - sparse_categorical_accuracy: 0.9017 - val_loss: 0.3621 - val_sparse_categorical_accuracy: 0.8516 Epoch 67/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2465 - sparse_categorical_accuracy: 0.9156 - val_loss: 0.3608 - val_sparse_categorical_accuracy: 0.8488 Epoch 68/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2502 - sparse_categorical_accuracy: 0.9101 - val_loss: 0.3557 - val_sparse_categorical_accuracy: 0.8627 Epoch 69/200 45/45 [==============================] - 23s 517ms/step - loss: 0.2418 - sparse_categorical_accuracy: 0.9104 - val_loss: 0.3561 - val_sparse_categorical_accuracy: 0.8502 Epoch 70/200 45/45 [==============================] - 23s 516ms/step - loss: 0.2463 - sparse_categorical_accuracy: 0.9049 - val_loss: 0.3554 - val_sparse_categorical_accuracy: 0.8613 Epoch 71/200 45/45 [==============================] - 23s 520ms/step - loss: 0.2372 - sparse_categorical_accuracy: 0.9177 - val_loss: 0.3548 - val_sparse_categorical_accuracy: 0.8627 Epoch 72/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2365 - sparse_categorical_accuracy: 0.9118 - val_loss: 0.3528 - val_sparse_categorical_accuracy: 0.8655 Epoch 73/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2420 - sparse_categorical_accuracy: 0.9083 - val_loss: 0.3510 - val_sparse_categorical_accuracy: 0.8655 Epoch 74/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2342 - sparse_categorical_accuracy: 0.9205 - val_loss: 0.3478 - val_sparse_categorical_accuracy: 0.8669 Epoch 75/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2337 - sparse_categorical_accuracy: 0.9062 - val_loss: 0.3484 - val_sparse_categorical_accuracy: 0.8655 Epoch 76/200 45/45 [==============================] - 23s 516ms/step - loss: 0.2298 - sparse_categorical_accuracy: 0.9153 - val_loss: 0.3478 - val_sparse_categorical_accuracy: 0.8585 Epoch 77/200 45/45 [==============================] - 23s 516ms/step - loss: 0.2218 - sparse_categorical_accuracy: 0.9243 - val_loss: 0.3467 - val_sparse_categorical_accuracy: 0.8613 Epoch 78/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2352 - sparse_categorical_accuracy: 0.9083 - val_loss: 0.3431 - val_sparse_categorical_accuracy: 0.8641 Epoch 79/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2218 - sparse_categorical_accuracy: 0.9194 - val_loss: 0.3448 - val_sparse_categorical_accuracy: 0.8613 Epoch 80/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2246 - sparse_categorical_accuracy: 0.9198 - val_loss: 0.3417 - val_sparse_categorical_accuracy: 0.8682 Epoch 81/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2168 - sparse_categorical_accuracy: 0.9201 - val_loss: 0.3397 - val_sparse_categorical_accuracy: 0.8641 Epoch 82/200 45/45 [==============================] - 23s 517ms/step - loss: 0.2254 - sparse_categorical_accuracy: 0.9153 - val_loss: 0.3373 - val_sparse_categorical_accuracy: 0.8682 Epoch 83/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2230 - sparse_categorical_accuracy: 0.9194 - val_loss: 0.3391 - val_sparse_categorical_accuracy: 0.8655 Epoch 84/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2124 - sparse_categorical_accuracy: 0.9240 - val_loss: 0.3370 - val_sparse_categorical_accuracy: 0.8682 Epoch 85/200 45/45 [==============================] - 23s 515ms/step - loss: 0.2123 - sparse_categorical_accuracy: 0.9278 - val_loss: 0.3394 - val_sparse_categorical_accuracy: 0.8571 Epoch 86/200 45/45 [==============================] - 23s 520ms/step - loss: 0.2119 - sparse_categorical_accuracy: 0.9260 - val_loss: 0.3355 - val_sparse_categorical_accuracy: 0.8627 Epoch 87/200 45/45 [==============================] - 23s 517ms/step - loss: 0.2052 - sparse_categorical_accuracy: 0.9247 - val_loss: 0.3353 - val_sparse_categorical_accuracy: 0.8738 Epoch 88/200 45/45 [==============================] - 23s 518ms/step - loss: 0.2089 - sparse_categorical_accuracy: 0.9299 - val_loss: 0.3342 - val_sparse_categorical_accuracy: 0.8779 Epoch 89/200 45/45 [==============================] - 23s 519ms/step - loss: 0.2027 - sparse_categorical_accuracy: 0.9250 - val_loss: 0.3353 - val_sparse_categorical_accuracy: 0.8793 Epoch 90/200 45/45 [==============================] - 23s 517ms/step - loss: 0.2110 - sparse_categorical_accuracy: 0.9264 - val_loss: 0.3320 - val_sparse_categorical_accuracy: 0.8752 Epoch 91/200 45/45 [==============================] - 23s 516ms/step - loss: 0.1965 - sparse_categorical_accuracy: 0.9292 - val_loss: 0.3339 - val_sparse_categorical_accuracy: 0.8710 Epoch 92/200 45/45 [==============================] - 23s 520ms/step - loss: 0.2030 - sparse_categorical_accuracy: 0.9253 - val_loss: 0.3296 - val_sparse_categorical_accuracy: 0.8752 Epoch 93/200 45/45 [==============================] - 23s 519ms/step - loss: 0.1969 - sparse_categorical_accuracy: 0.9347 - val_loss: 0.3298 - val_sparse_categorical_accuracy: 0.8807 Epoch 94/200 45/45 [==============================] - 23s 518ms/step - loss: 0.1939 - sparse_categorical_accuracy: 0.9295 - val_loss: 0.3300 - val_sparse_categorical_accuracy: 0.8779 Epoch 95/200 45/45 [==============================] - 23s 517ms/step - loss: 0.1930 - sparse_categorical_accuracy: 0.9330 - val_loss: 0.3305 - val_sparse_categorical_accuracy: 0.8766 Epoch 96/200 45/45 [==============================] - 23s 518ms/step - loss: 0.1946 - sparse_categorical_accuracy: 0.9288 - val_loss: 0.3288 - val_sparse_categorical_accuracy: 0.8669 Epoch 97/200 45/45 [==============================] - 23s 518ms/step - loss: 0.1951 - sparse_categorical_accuracy: 0.9264 - val_loss: 0.3281 - val_sparse_categorical_accuracy: 0.8682 Epoch 98/200 45/45 [==============================] - 23s 516ms/step - loss: 0.1899 - sparse_categorical_accuracy: 0.9354 - val_loss: 0.3307 - val_sparse_categorical_accuracy: 0.8696 Epoch 99/200 45/45 [==============================] - 23s 519ms/step - loss: 0.1901 - sparse_categorical_accuracy: 0.9250 - val_loss: 0.3307 - val_sparse_categorical_accuracy: 0.8710 Epoch 100/200 45/45 [==============================] - 23s 516ms/step - loss: 0.1902 - sparse_categorical_accuracy: 0.9319 - val_loss: 0.3259 - val_sparse_categorical_accuracy: 0.8696 Epoch 101/200 45/45 [==============================] - 23s 518ms/step - loss: 0.1868 - sparse_categorical_accuracy: 0.9358 - val_loss: 0.3262 - val_sparse_categorical_accuracy: 0.8724 Epoch 102/200 45/45 [==============================] - 23s 518ms/step - loss: 0.1779 - sparse_categorical_accuracy: 0.9431 - val_loss: 0.3250 - val_sparse_categorical_accuracy: 0.8710 Epoch 103/200 45/45 [==============================] - 23s 520ms/step - loss: 0.1870 - sparse_categorical_accuracy: 0.9351 - val_loss: 0.3260 - val_sparse_categorical_accuracy: 0.8724 Epoch 104/200 45/45 [==============================] - 23s 521ms/step - loss: 0.1826 - sparse_categorical_accuracy: 0.9344 - val_loss: 0.3232 - val_sparse_categorical_accuracy: 0.8766 Epoch 105/200 45/45 [==============================] - 23s 519ms/step - loss: 0.1731 - sparse_categorical_accuracy: 0.9399 - val_loss: 0.3245 - val_sparse_categorical_accuracy: 0.8724 Epoch 106/200 45/45 [==============================] - 23s 518ms/step - loss: 0.1766 - sparse_categorical_accuracy: 0.9361 - val_loss: 0.3254 - val_sparse_categorical_accuracy: 0.8682 Epoch 107/200 Conclusions In about 110-120 epochs (25s each on Colab), the model reaches a training accuracy of ~0.95, validation accuracy of ~84 and a testing accuracy of ~85, without hyperparameter tuning. And that is for a model with less than 100k parameters. Of course, parameter count and accuracy could be improved by a hyperparameter search and a more sophisticated learning rate schedule, or a different optimizer. This notebook demonstrates how to do timeseries forecasting using a LSTM model. Setup This example requires TensorFlow 2.3 or higher. import pandas as pd import matplotlib.pyplot as plt import tensorflow as tf from tensorflow import keras Climate Data Time-Series We will be using Jena Climate dataset recorded by the Max Planck Institute for Biogeochemistry. The dataset consists of 14 features such as temperature, pressure, humidity etc, recorded once per 10 minutes. Location: Weather Station, Max Planck Institute for Biogeochemistry in Jena, Germany Time-frame Considered: Jan 10, 2009 - December 31, 2016 The table below shows the column names, their value formats, and their description. Index Features Format Description 1 Date Time 01.01.2009 00:10:00 Date-time reference 2 p (mbar) 996.52 The pascal SI derived unit of pressure used to quantify internal pressure. Meteorological reports typically state atmospheric pressure in millibars. 3 T (degC) -8.02 Temperature in Celsius 4 Tpot (K) 265.4 Temperature in Kelvin 5 Tdew (degC) -8.9 Temperature in Celsius relative to humidity. Dew Point is a measure of the absolute amount of water in the air, the DP is the temperature at which the air cannot hold all the moisture in it and water condenses. 6 rh (%) 93.3 Relative Humidity is a measure of how saturated the air is with water vapor, the %RH determines the amount of water contained within collection objects. 7 VPmax (mbar) 3.33 Saturation vapor pressure 8 VPact (mbar) 3.11 Vapor pressure 9 VPdef (mbar) 0.22 Vapor pressure deficit 10 sh (g/kg) 1.94 Specific humidity 11 H2OC (mmol/mol) 3.12 Water vapor concentration 12 rho (g/m ** 3) 1307.75 Airtight 13 wv (m/s) 1.03 Wind speed 14 max. wv (m/s) 1.75 Maximum wind speed 15 wd (deg) 152.3 Wind direction in degrees from zipfile import ZipFile import os uri = \"https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip\" zip_path = keras.utils.get_file(origin=uri, fname=\"jena_climate_2009_2016.csv.zip\") zip_file = ZipFile(zip_path) zip_file.extractall() csv_path = \"jena_climate_2009_2016.csv\" df = pd.read_csv(csv_path) Raw Data Visualization To give us a sense of the data we are working with, each feature has been plotted below. This shows the distinct pattern of each feature over the time period from 2009 to 2016. It also shows where anomalies are present, which will be addressed during normalization. titles = [ \"Pressure\", \"Temperature\", \"Temperature in Kelvin\", \"Temperature (dew point)\", \"Relative Humidity\", \"Saturation vapor pressure\", \"Vapor pressure\", \"Vapor pressure deficit\", \"Specific humidity\", \"Water vapor concentration\", \"Airtight\", \"Wind speed\", \"Maximum wind speed\", \"Wind direction in degrees\", ] feature_keys = [ \"p (mbar)\", \"T (degC)\", \"Tpot (K)\", \"Tdew (degC)\", \"rh (%)\", \"VPmax (mbar)\", \"VPact (mbar)\", \"VPdef (mbar)\", \"sh (g/kg)\", \"H2OC (mmol/mol)\", \"rho (g/m**3)\", \"wv (m/s)\", \"max. wv (m/s)\", \"wd (deg)\", ] colors = [ \"blue\", \"orange\", \"green\", \"red\", \"purple\", \"brown\", \"pink\", \"gray\", \"olive\", \"cyan\", ] date_time_key = \"Date Time\" def show_raw_visualization(data): time_data = data[date_time_key] fig, axes = plt.subplots( nrows=7, ncols=2, figsize=(15, 20), dpi=80, facecolor=\"w\", edgecolor=\"k\" ) for i in range(len(feature_keys)): key = feature_keys[i] c = colors[i % (len(colors))] t_data = data[key] t_data.index = time_data t_data.head() ax = t_data.plot( ax=axes[i // 2, i % 2], color=c, title=\"{} - {}\".format(titles[i], key), rot=25, ) ax.legend([titles[i]]) plt.tight_layout() show_raw_visualization(df) png This heat map shows the correlation between different features. def show_heatmap(data): plt.matshow(data.corr()) plt.xticks(range(data.shape[1]), data.columns, fontsize=14, rotation=90) plt.gca().xaxis.tick_bottom() plt.yticks(range(data.shape[1]), data.columns, fontsize=14) cb = plt.colorbar() cb.ax.tick_params(labelsize=14) plt.title(\"Feature Correlation Heatmap\", fontsize=14) plt.show() show_heatmap(df) png Data Preprocessing Here we are picking ~300,000 data points for training. Observation is recorded every 10 mins, that means 6 times per hour. We will resample one point per hour since no drastic change is expected within 60 minutes. We do this via the sampling_rate argument in timeseries_dataset_from_array utility. We are tracking data from past 720 timestamps (720/6=120 hours). This data will be used to predict the temperature after 72 timestamps (72/6=12 hours). Since every feature has values with varying ranges, we do normalization to confine feature values to a range of [0, 1] before training a neural network. We do this by subtracting the mean and dividing by the standard deviation of each feature. 71.5 % of the data will be used to train the model, i.e. 300,693 rows. split_fraction can be changed to alter this percentage. The model is shown data for first 5 days i.e. 720 observations, that are sampled every hour. The temperature after 72 (12 hours * 6 observation per hour) observation will be used as a label. split_fraction = 0.715 train_split = int(split_fraction * int(df.shape[0])) step = 6 past = 720 future = 72 learning_rate = 0.001 batch_size = 256 epochs = 10 def normalize(data, train_split): data_mean = data[:train_split].mean(axis=0) data_std = data[:train_split].std(axis=0) return (data - data_mean) / data_std We can see from the correlation heatmap, few parameters like Relative Humidity and Specific Humidity are redundant. Hence we will be using select features, not all. print( \"The selected parameters are:\", \", \".join([titles[i] for i in [0, 1, 5, 7, 8, 10, 11]]), ) selected_features = [feature_keys[i] for i in [0, 1, 5, 7, 8, 10, 11]] features = df[selected_features] features.index = df[date_time_key] features.head() features = normalize(features.values, train_split) features = pd.DataFrame(features) features.head() train_data = features.loc[0 : train_split - 1] val_data = features.loc[train_split:] The selected parameters are: Pressure, Temperature, Saturation vapor pressure, Vapor pressure deficit, Specific humidity, Airtight, Wind speed Training dataset The training dataset labels starts from the 792nd observation (720 + 72). start = past + future end = start + train_split x_train = train_data[[i for i in range(7)]].values y_train = features.iloc[start:end][[1]] sequence_length = int(past / step) The timeseries_dataset_from_array function takes in a sequence of data-points gathered at equal intervals, along with time series parameters such as length of the sequences/windows, spacing between two sequence/windows, etc., to produce batches of sub-timeseries inputs and targets sampled from the main timeseries. dataset_train = keras.preprocessing.timeseries_dataset_from_array( x_train, y_train, sequence_length=sequence_length, sampling_rate=step, batch_size=batch_size, ) Validation dataset The validation dataset must not contain the last 792 rows as we won't have label data for those records, hence 792 must be subtracted from the end of the data. The validation label dataset must start from 792 after train_split, hence we must add past + future (792) to label_start. x_end = len(val_data) - past - future label_start = train_split + past + future x_val = val_data.iloc[:x_end][[i for i in range(7)]].values y_val = features.iloc[label_start:][[1]] dataset_val = keras.preprocessing.timeseries_dataset_from_array( x_val, y_val, sequence_length=sequence_length, sampling_rate=step, batch_size=batch_size, ) for batch in dataset_train.take(1): inputs, targets = batch print(\"Input shape:\", inputs.numpy().shape) print(\"Target shape:\", targets.numpy().shape) Input shape: (256, 120, 7) Target shape: (256, 1) Training inputs = keras.layers.Input(shape=(inputs.shape[1], inputs.shape[2])) lstm_out = keras.layers.LSTM(32)(inputs) outputs = keras.layers.Dense(1)(lstm_out) model = keras.Model(inputs=inputs, outputs=outputs) model.compile(optimizer=keras.optimizers.Adam(learning_rate=learning_rate), loss=\"mse\") model.summary() Model: \"functional_1\" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) [(None, 120, 7)] 0 _________________________________________________________________ lstm (LSTM) (None, 32) 5120 _________________________________________________________________ dense (Dense) (None, 1) 33 ================================================================= Total params: 5,153 Trainable params: 5,153 Non-trainable params: 0 _________________________________________________________________ We'll use the ModelCheckpoint callback to regularly save checkpoints, and the EarlyStopping callback to interrupt training when the validation loss is not longer improving. path_checkpoint = \"model_checkpoint.h5\" es_callback = keras.callbacks.EarlyStopping(monitor=\"val_loss\", min_delta=0, patience=5) modelckpt_callback = keras.callbacks.ModelCheckpoint( monitor=\"val_loss\", filepath=path_checkpoint, verbose=1, save_weights_only=True, save_best_only=True, ) history = model.fit( dataset_train, epochs=epochs, validation_data=dataset_val, callbacks=[es_callback, modelckpt_callback], ) Epoch 1/10 1172/1172 [==============================] - ETA: 0s - loss: 0.2059 Epoch 00001: val_loss improved from inf to 0.16357, saving model to model_checkpoint.h5 1172/1172 [==============================] - 101s 86ms/step - loss: 0.2059 - val_loss: 0.1636 Epoch 2/10 1172/1172 [==============================] - ETA: 0s - loss: 0.1271 Epoch 00002: val_loss improved from 0.16357 to 0.13362, saving model to model_checkpoint.h5 1172/1172 [==============================] - 107s 92ms/step - loss: 0.1271 - val_loss: 0.1336 Epoch 3/10 1172/1172 [==============================] - ETA: 0s - loss: 0.1089 Epoch 00005: val_loss did not improve from 0.13362 1172/1172 [==============================] - 110s 94ms/step - loss: 0.1089 - val_loss: 0.1481 Epoch 6/10 271/1172 [=====>........................] - ETA: 1:12 - loss: 0.1117 We can visualize the loss with the function below. After one point, the loss stops decreasing. def visualize_loss(history, title): loss = history.history[\"loss\"] val_loss = history.history[\"val_loss\"] epochs = range(len(loss)) plt.figure() plt.plot(epochs, loss, \"b\", label=\"Training loss\") plt.plot(epochs, val_loss, \"r\", label=\"Validation loss\") plt.title(title) plt.xlabel(\"Epochs\") plt.ylabel(\"Loss\") plt.legend() plt.show() visualize_loss(history, \"Training and Validation Loss\") png Prediction The trained model above is now able to make predictions for 5 sets of values from validation set. def show_plot(plot_data, delta, title): labels = [\"History\", \"True Future\", \"Model Prediction\"] marker = [\".-\", \"rx\", \"go\"] time_steps = list(range(-(plot_data[0].shape[0]), 0)) if delta: future = delta else: future = 0 plt.title(title) for i, val in enumerate(plot_data): if i: plt.plot(future, plot_data[i], marker[i], markersize=10, label=labels[i]) else: plt.plot(time_steps, plot_data[i].flatten(), marker[i], label=labels[i]) plt.legend() plt.xlim([time_steps[0], (future + 5) * 2]) plt.xlabel(\"Time-Step\") plt.show() return for x, y in dataset_val.take(5): show_plot( [x[0][:, 1].numpy(), y[0].numpy(), model.predict(x)[0]], 12, \"Single Step Prediction\", ) png png png png png