Transfer Learning TF

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np
import os
# Self-contained course computer-vision helpers.
from pathlib import Path
import glob
from PIL import Image

def plot_convolution(data, kernel, title=""):
    fig, axes = plt.subplots(2, len(data) + 1, figsize=(10, 4))
    fig.suptitle(title, fontsize=16)
    tensor_kernel = np.asarray(kernel, dtype=np.float32)[:, :, None, None]
    for index, image in enumerate(data):
        axes[0, index].imshow(image, cmap="gray")
        tensor_image = np.asarray(image, dtype=np.float32)[None, :, :, None]
        convolved = tf.nn.conv2d(tensor_image, tensor_kernel, strides=1, padding="SAME")
        axes[1, index].imshow(convolved[0, :, :, 0], cmap="gray")
        axes[0, index].axis("off")
        axes[1, index].axis("off")
    axes[0, -1].imshow(kernel, cmap="gray")
    axes[0, -1].axis("off")
    axes[1, -1].axis("off")
    plt.tight_layout()
    plt.show()

def plot_results(history):
    fig, axes = plt.subplots(1, 2, figsize=(12, 4))
    axes[0].set_title("Accuracy")
    axes[1].set_title("Loss")
    for key in ("accuracy", "val_accuracy"):
        if key in history.history:
            axes[0].plot(history.history[key], label=key)
    for key in ("loss", "val_loss"):
        if key in history.history:
            axes[1].plot(history.history[key], label=key)
    axes[0].legend()
    axes[1].legend()
    plt.show()

def display_dataset(dataset, labels=None, n=10, classes=None):
    count = min(n, len(dataset))
    fig, axes = plt.subplots(1, count, figsize=(1.8 * count, 3))
    axes = np.atleast_1d(axes)
    for index in range(count):
        axes[index].imshow(dataset[index])
        axes[index].axis("off")
        if classes is not None and labels is not None:
            label = int(np.asarray(labels[index]).reshape(-1)[0])
            axes[index].set_title(classes[label])
    plt.show()

def check_image(filename):
    try:
        with Image.open(filename) as image:
            image.verify()
        return True
    except (OSError, SyntaxError):
        return False

def check_image_dir(pattern):
    invalid = [filename for filename in glob.glob(pattern) if not check_image(filename)]
    if invalid:
        names = ", ".join(Path(filename).name for filename in invalid[:5])
        raise ValueError(f"Invalid images detected ({len(invalid)}): {names}")
    return 0

from pathlib import Path

course_data_dir = Path("data/course-pets")

def course_pet_image(kind, index, size=224):
    rng = np.random.default_rng(10_000 + index + (0 if kind == "Cat" else 1_000))
    y, x = np.mgrid[0:size, 0:size]
    image = np.full((size, size, 3), 0.12, dtype="float32")
    image += rng.normal(0, 0.025, image.shape).astype("float32")
    cx, cy = size // 2 + rng.integers(-12, 13, size=2)
    face = (x - cx) ** 2 + (y - cy) ** 2 < (size * 0.27) ** 2
    if kind == "Cat":
        ears = ((y < cy - size * 0.18) & (np.abs(x - cx) > size * 0.12) & (np.abs(x - cx) < size * 0.3))
        shape = face | ears
        color = np.array([0.85, 0.58, 0.25], dtype="float32")
    else:
        ears = (((x - (cx - size * 0.3)) / (size * 0.14)) ** 2 + ((y - cy) / (size * 0.25)) ** 2 < 1) | (((x - (cx + size * 0.3)) / (size * 0.14)) ** 2 + ((y - cy) / (size * 0.25)) ** 2 < 1)
        shape = face | ears
        color = np.array([0.35, 0.62, 0.88], dtype="float32")
    image[shape] = color
    return np.clip(image, 0, 1)

for class_name in ("Cat", "Dog"):
    class_dir = course_data_dir / class_name
    class_dir.mkdir(parents=True, exist_ok=True)
    for index in range(48):
        keras.utils.save_img(class_dir / f"{index:03}.png", course_pet_image(class_name, index))

data_dir = str(course_data_dir)

print(f"Prepared the deterministic course fixture at {data_dir}.")

check_image_dir(f"{data_dir}/Cat/*.png")
check_image_dir(f"{data_dir}/Dog/*.png")

batch_size = 16
ds_train = keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=13,
    image_size=(224, 224),
    batch_size=batch_size,
)
ds_test = keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=13,
    image_size=(224, 224),
    batch_size=batch_size,
)

ds_train.class_names

for x,y in ds_train:
    print(f"Training batch shape: features={x.shape}, labels={y.shape}")
    x_sample, y_sample = x,y
    break

display_dataset(x_sample.numpy().astype(np.int64),np.expand_dims(y_sample,1),classes=ds_train.class_names)

vgg = keras.applications.VGG16(weights=None)
inp = keras.applications.vgg16.preprocess_input(x_sample[:1])
res = vgg(inp)
predicted_index = int(tf.argmax(res, axis=1)[0])
print(f"Fixture-model output index = {predicted_index}")

vgg.summary()

tf.config.list_physical_devices('GPU')

vgg = keras.applications.VGG16(include_top=False, weights=None)

inp = keras.applications.vgg16.preprocess_input(x_sample[:1])
res = vgg(inp)
print(f"Shape after applying VGG-16: {res[0].shape}")
plt.figure(figsize=(15,3))
plt.imshow(res[0].numpy().reshape(-1,512))

num = batch_size*50
ds_features_train = ds_train.take(50).map(lambda x,y : (vgg(keras.applications.vgg16.preprocess_input(x)), y))
ds_features_test = ds_test.take(10).map(lambda x,y : (vgg(keras.applications.vgg16.preprocess_input(x)), y))

for x,y in ds_features_train:
    print(x.shape,y.shape)
    break

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=(7,7,512)),
    keras.layers.Dense(1,activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
hist = model.fit(ds_features_train, validation_data=ds_features_test)

model = keras.models.Sequential()
model.add(keras.applications.VGG16(include_top=False, weights=None, input_shape=(224,224,3)))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(1,activation='sigmoid'))

model.layers[0].trainable = False

model.summary()

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
hist = model.fit(ds_train, validation_data=ds_test)

model.save("data/cats_dogs.keras")

model = keras.models.load_model("data/cats_dogs.keras")

model.layers[0].summary()

model.layers[0].trainable = True

for i in range(len(model.layers[0].layers)-4):
    model.layers[0].layers[i].trainable = False
model.summary()
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-5),
    loss="binary_crossentropy",
    metrics=["acc"],
)

hist = model.fit(ds_train, validation_data=ds_test)

resnet = keras.applications.ResNet50(weights=None)
resnet.summary()