Chapter 42: Image Augmentation

import warnings

import numpy as np
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression

from kaggle_companion.activities._common import clean

warnings.filterwarnings("ignore")      # lbfgs convergence notices on tiny training sets
SEED = 42
REPLICATES = 12          # independent train/test splits per training size; results are means over them
TEST_ROWS = 500
POLICIES = ("none", "duplicate", "shift", "hflip", "rot180")


def shifted(image, rng):
    """Move the 8 x 8 image by -1, 0 or +1 pixel in each direction, padding with zeros."""
    dx, dy = rng.integers(-1, 2, 2)
    out = np.zeros_like(image)
    src = image[max(0, -dy):8 - max(0, dy), max(0, -dx):8 - max(0, dx)]
    out[max(0, dy):max(0, dy) + src.shape[0], max(0, dx):max(0, dx) + src.shape[1]] = src
    return out


TRANSFORMS = {"duplicate": lambda im, rng: im,                 # control: same rows twice, no change to the picture
              "shift": shifted,
              "hflip": lambda im, rng: im[:, ::-1],            # mirror left to right
              "rot180": lambda im, rng: im[::-1, ::-1]}        # turn upside down (a 6 becomes a 9)


def fit_predict(images, labels, test_images, policy, rng):
    """Train on the originals plus one transformed copy of each (or on the originals alone) and predict the test images."""
    if policy != "none":
        copies = np.stack([TRANSFORMS[policy](im, rng) for im in images])
        images, labels = np.concatenate([images, copies]), np.concatenate([labels, labels])
    model = LogisticRegression(max_iter=300).fit(images.reshape(len(images), -1), labels)
    return model.predict(test_images.reshape(len(test_images), -1))


def run(training_images):
    digits = load_digits()
    pictures, labels = digits.images / 16.0, digits.target     # 1,797 real 8 x 8 grayscale scans, scaled to [0, 1]
    accuracy = {v: {p: [] for p in POLICIES} for v in ("scanned", "mirrored")}
    swapped = {p: [] for p in ("none", "rot180")}              # share of true 6s and 9s predicted as the other one
    for r in range(REPLICATES):
        rng = np.random.default_rng(SEED * 100 + r)
        order = rng.permutation(len(labels))
        test, train = order[:TEST_ROWS], order[TEST_ROWS:TEST_ROWS + training_images]
        mirror = rng.random(len(labels)) < 0.5
        variants = {"scanned": pictures,                                                   # digits as scanned: orientation carries the label
                    "mirrored": np.where(mirror[:, None, None], pictures[:, :, ::-1], pictures)}   # constructed: half the images mirrored, labels unchanged
        for variant, images in variants.items():
            for policy in POLICIES:
                pred = fit_predict(images[train], labels[train], images[test], policy, np.random.default_rng(r))
                accuracy[variant][policy].append(float((pred == labels[test]).mean()))
                if variant == "scanned" and policy in swapped:
                    six_nine = np.isin(labels[test], (6, 9))
                    swapped[policy].append(float((pred[six_nine] == 15 - labels[test][six_nine]).mean()))
    mean = {v: {p: float(np.mean(a)) for p, a in d.items()} for v, d in accuracy.items()}
    return clean({"training_images": training_images, "accuracy": mean, "swapped_six_nine": {p: float(np.mean(a)) for p, a in swapped.items()},
                  "replicates": REPLICATES, "test_images": TEST_ROWS})

import pandas as pd
from kaggle_companion.activities.ch42 import explain

VALUES = [100, 300, 900]
results = {value: run(value) for value in VALUES}
table = pd.DataFrame({str(v): explain(results[v], v)['metrics'] for v in VALUES})
print(table.to_string())

import matplotlib.pyplot as plt
from kaggle_companion.activities.ch42 import draw, NCOLS, HEIGHT

DEFAULT = 100
fig, axes = plt.subplots(1, NCOLS, figsize=(6.6 if NCOLS == 1 else 10.4, HEIGHT), layout='constrained')
draw(axes, results[DEFAULT], DEFAULT)
plt.show()