Python and Covolutional Neural Network

新版的 RStudio 可以在單一介面下使用多種語言，這裡我演示一下同時用 Python 和 R，透過「卷積神經網絡(CNN，Convolutional Neural Network)」來做臉孔辨識。即使在相當低的解析度(28*28)之下，模型還是可以有不錯的辨識率(97.5%)，CNN的威力可見一般。程式的解說請參考 原PO。

Installation

因為這些Packages比較新，你可能需要用以下的方法做安裝和設定：

# install EBImage from Bioconductor
source("http://bioconductor.org/biocLite.R")
biocLite("EBImage")

# install mxnet its own repo
install.packages("drat", repos="https://cran.rstudio.com")
drat:::addRepo("dmlc")
install.packages("mxnet")

# You may also need to re-install DiagrammeR for a compatability issue.
# Hopefully this step won't be needed in the near future.
remove.packages("DiagrammeR")
require(devtools)
packageurl <- "http://cran.us.r-project.org/src/contrib/Archive/DiagrammeR/DiagrammeR_0.8.1.tar.gz"
install.packages(packageurl, repos=NULL, type="source")

Loading & Pre-Processing

# Imports
from sklearn.datasets import fetch_olivetti_faces
import numpy as np

# Download Olivetti faces dataset
olivetti = fetch_olivetti_faces('data')
x = olivetti.images
y = olivetti.target

# Print info on shapes and reshape where necessary
print("Original x shape:", x.shape)
X = x.reshape((400, 4096))
print("New x shape:", X.shape)
print("y shape", y.shape)

# Save the numpy arrays
np.savetxt("olivetti_X.csv", X, delimiter = ",")
np.savetxt("olivetti_y.csv", y, delimiter = ",", fmt = '%d')

print("\nDownloading and reshaping done!")

Original x shape: (400, 64, 64)
New x shape: (400, 4096)
y shape (400,)

Downloading and reshaping done!

Reshaping

# This script is used to resize images from 64x64 to 28x28 pixels

# Clear workspace
rm(list=ls())

# Load EBImage library
require(EBImage)

# Load data
X <- read.csv("olivetti_X.csv", header = F)
labels <- read.csv("olivetti_y.csv", header = F)

# Dataframe of resized images
rs_df <- data.frame()

# Main loop: for each image, resize and set it to greyscale
for(i in 1:nrow(X))
{
    # Try-catch
    result <- tryCatch({
    # Image (as 1d vector)
    img <- as.numeric(X[i,])
    # Reshape as a 64x64 image (EBImage object)
    img <- Image(img, dim=c(64, 64), colormode = "Grayscale")
    # Resize image to 28x28 pixels
    img_resized <- resize(img, w = 28, h = 28)
    # Get image matrix (there should be another function 
    # to do this faster and more neatly!)
    img_matrix <- img_resized@.Data
    # Coerce to a vector
    img_vector <- as.vector(t(img_matrix))
    # Add label
    label <- labels[i,]
    vec <- c(label, img_vector)
    # Stack in rs_df using rbind
    rs_df <- rbind(rs_df, vec)
    # Print status
    print(paste("Done",i,sep = " "))},
    # Error function (just prints the error). Btw you should get no errors!
    error = function(e){print(e)})
}


# Set names. The first columns are the labels, the other columns are the pixels.
names(rs_df) <- c("label", paste("pixel", c(1:784)))

Output omitted.

Original Image

par(mfrow=c(2,5),mar=c(1,1,1,1))
for(i in 1:10) {
  img <- as.numeric(X[i,])
  img <- Image(img, dim=c(64, 64), colormode = "Grayscale")
  m = t(apply(img@.Data, 1, rev))
  image(m, axes = FALSE, col = grey(seq(0, 1, length = 256)))
}

Resuce the resolution

par(mfrow=c(2,5),mar=c(1,1,1,1))
for(i in 1:10) {
  m = matrix(as.numeric(rs_df[i,2:ncol(rs_df)]),28,28,byrow=T)
  m = t(apply(m, 1, rev))
  image(m, axes = FALSE, col = grey(seq(0, 1, length = 256))) }

# Train-test split
#-------------------------------------------------------------------------------
# Simple train-test split. No crossvalidation is done in this tutorial.
# Set seed for reproducibility purposes
set.seed(100)
# Shuffled df
shuffled <- rs_df[sample(1:400),]
# Train-test split
train_28 <- shuffled[1:360, ]
test_28 <- shuffled[361:400, ]
# Save train-test datasets
write.csv(train_28, "train_28.csv", row.names = FALSE)
write.csv(test_28, "test_28.csv", row.names = FALSE)
# Done!
print("Done!")

[1] "Done!"

Train a CNN Model

Setup

# Clean workspace
rm(list=ls())
# Load MXNet
require(mxnet)

Loading required package: mxnet

Init Rcpp

# Loading data and set up
#-------------------------------------------------------------------------------
# Load train and test datasets
train <- read.csv("train_28.csv")
test <- read.csv("test_28.csv")
# Set up train and test datasets
train <- data.matrix(train)
train_x <- t(train[, -1])
train_y <- train[, 1]
train_array <- train_x
dim(train_array) <- c(28, 28, 1, ncol(train_x))
test_x <- t(test[, -1])
test_y <- test[, 1]
test_array <- test_x
dim(test_array) <- c(28, 28, 1, ncol(test_x))
# Set up the symbolic model
#-------------------------------------------------------------------------------
data <- mx.symbol.Variable('data')
# 1st convolutional layer
conv_1 <- mx.symbol.Convolution(data = data, kernel = c(5, 5), num_filter = 20)
tanh_1 <- mx.symbol.Activation(data = conv_1, act_type = "tanh")
pool_1 <- mx.symbol.Pooling(data = tanh_1, pool_type = "max", kernel = c(2, 2), stride = c(2, 2))
# 2nd convolutional layer
conv_2 <- mx.symbol.Convolution(data = pool_1, kernel = c(5, 5), num_filter = 50)
tanh_2 <- mx.symbol.Activation(data = conv_2, act_type = "tanh")
pool_2 <- mx.symbol.Pooling(data=tanh_2, pool_type = "max", kernel = c(2, 2), stride = c(2, 2))
# 1st fully connected layer
flatten <- mx.symbol.Flatten(data = pool_2)
fc_1 <- mx.symbol.FullyConnected(data = flatten, num_hidden = 500)
tanh_3 <- mx.symbol.Activation(data = fc_1, act_type = "tanh")
# 2nd fully connected layer
fc_2 <- mx.symbol.FullyConnected(data = tanh_3, num_hidden = 40)
# Output. Softmax output since we'd like to get some probabilities.
NN_model <- mx.symbol.SoftmaxOutput(data = fc_2)
# Set seed for reproducibility
mx.set.seed(100)
# Device used. CPU in my case.
devices <- mx.cpu()

Training

# Training
#-------------------------------------------------------------------------------
# Train the model
model <- mx.model.FeedForward.create(NN_model,
                                     X = train_array,
                                     y = train_y,
                                     ctx = devices,
                                     num.round = 400,
                                     array.batch.size = 40,
                                     learning.rate = 0.01,
                                     momentum = 0.9,
                                     eval.metric = mx.metric.accuracy,
                                     epoch.end.callback = mx.callback.log.train.metric(100))

Output omitted.

Predicting & Testing

# Predict labels
predicted <- predict(model, test_array)
# Assign labels
predicted_labels <- max.col(t(predicted)) - 1
# Get accuracy
sum(diag(table(test[, 1], predicted_labels)))/40

[1] 0.975