text stringlengths 0 4.99k |
|---|
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 9... |
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 de... |
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... |
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 th... |
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) |
) |
[1mDownloading 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...[0m |
WARNING:absl:1738 images were corrupted and were skipped |
[1mDataset cats_vs_dogs downloaded and prepared to /home/jupyter/tensorflow_datasets/cats_vs_dogs/4.0.0. Subsequent calls will reuse this data.[0m |
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) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.