Logistic regression for image classification

import numpy as np
import h5py

# Training rate
alpha = 0.002

def sigmoid(z):
    """Return the logistic function sigma(z) = 1/(1+exp(-z))."""
    return 1 / (1+np.exp(-z))

def cost(Y, Yhat):
    """Return the cost function for predictions Yhat of classifications Y."""
    return (- Y @ np.log(Yhat.T) - (1 - Y) @ np.log(1 - Yhat.T)) / m

def accuracy(Y, Yhat):
    """Return measure of the accuracy with which Yhat predicts Y."""
    return 1 - np.mean(np.abs(Y - Yhat.round()))

def model(X, w, b):
    """Apply the logistic model parameterized by w, b to features X."""
    z = w.T @ X + b
    Yhat = sigmoid(z)
    return z, Yhat


def train(X, Y, max_it=1000):
    """Train the logistic regression algorithm on the data X classified as Y."""

    # Parameter vector, w, and constant term (bias), b.
    # For random initialization, use the following:
    #w, b = np.random.random((nx,1)) * 0.01, 0.01
    # To initialize with zeros, use this line instead:
    w, b = np.zeros((nx,1)), 0

    def propagate(w, b):
        """Propagate the training by advancing w, b to reduce the cost, J."""
        z, Yhat = model(X, w, b)
        w -= alpha / m * (X @ (Yhat - Y).T)
        b -= alpha / m * np.sum(Yhat - Y)
        J = np.squeeze(cost(Y, Yhat))
        if not it % 100:
            # Provide an update on the progress we have made so far.
            print('{}: J = {}'.format(it, J))
            print('train accuracy = {:g}%'.format(accuracy(Y, Yhat) * 100))
        return w, b

    # Train the model by iteratively improving w, b.
    for it in range(max_it):
        w, b = propagate(w, b)
    return w, b

# Our training data, in an HDF5 file.
ds_train = h5py.File('dogs_train.h5', 'r')

# Normalise the pixel data (RGB channels) to be in the range 0-1.
ds_x = np.array(ds_train["dogs_train_x"]).T / 255
ds_y = np.array(ds_train["dogs_train_y"])

# Number of training examples.
m = len(ds_y)
# Dimension of the feature vector for each example.
nx = ds_x.size // m
# Packed feature vector and associated classification.
X, Y = ds_x.reshape((nx, m)), ds_y.reshape((1, m))

# Train the model
w, b = train(X, Y)


# Now the test data
ds_test = h5py.File('dogs_test.h5', 'r')
ds_x = np.array(ds_test["dogs_test_x"]).T / 255
ds_y = np.array(ds_test["dogs_test_y"])
# Number of test examples.
m = len(ds_y)
# Dimension of the feature vector for each example.
nx = ds_x.size // m
# Packed feature vector and associated classification.
X, Y = ds_x.reshape((nx, m)), ds_y.reshape((1,m))

z, Yhat = model(X, w, b)
print('test accuracy = {}%'.format(accuracy(Y, Yhat) * 100))

#import sys; sys.exit()

from PIL import Image

def categorize_image(filename):
    """Categorize the image provided in filename.

    Return 1 if the image is categorized in the y=1 class and otherwise 0.

    """

    im = Image.open(filename)
    ds_x = np.asarray(im, dtype='uint8')[:, :, :3].T / 255
    ds_y = np.array([1])
    # Number of test examples.
    m = len(ds_y)
    # Dimension of the feature vector for each example.
    nx = ds_x.size // m
    # Packed feature vector and associated classification.
    X, Y = ds_x.reshape((nx, m)), ds_y.reshape((1,m))
    z, Yhat = model(X, w, b)
    return np.squeeze(Yhat) > 0.5

def report_category(filename, predictedY):
    s = 'a Bedlington Terrier' if predictedY else 'an Afghan Hound'
    print(filename, 'is ' + s)

filename = 'afghan.png'
report_category(filename, categorize_image(filename))

filename = 'bedlington.png'
report_category(filename, categorize_image(filename))

filename = 'lamb.png'
report_category(filename, categorize_image(filename))

0: J = 0.6931471805599454
train accuracy = 49.3976%
100: J = 0.40646680736736357
train accuracy = 83.9357%
200: J = 0.30963910029260394
train accuracy = 92.7711%
300: J = 0.27044432864585155
train accuracy = 93.1727%
400: J = 0.2403748716897039
train accuracy = 94.7791%
500: J = 0.21618082409768039
train accuracy = 96.3855%
600: J = 0.1961962194683076
train accuracy = 96.7871%
700: J = 0.17939225598255604
train accuracy = 97.1888%
800: J = 0.16506777147246057
train accuracy = 97.5904%
900: J = 0.1527192203531857
train accuracy = 97.5904%
test accuracy = 82.35294117647058%
afghan.png is an Afghan Hound
bedlington.png is a Bedlington Terrier
lamb.png is a Bedlington Terrier