The following libraries will be required to learn and execute the project in this chapter:

• Python
• Anaconda
• Jupyter Notebook
• PyTorch
• Matplotlib
• Scikit-learn

You can find the code files for this chapter in the GitHub repository of this book: https://github.com/PacktPublishing/Hands-on-One-Shot-Learning-with-Python.

The human brain has been a subject of research since the beginning of civilization. If we look into the development of a child, we will observe that as they grow, their ability to learn also grows. First, they learn about food, then they learn to identify faces. Every time a child learns something, information is encoded into some portion of the brain. Still, the real question remains, how does information get stored in our brains? Why is some information hardcoded, yet other information is easily forgotten?

Most of the information on how the brain trains itself to process data is unknown, but there are various theories that explore it. If we look into the structure of a brain's neuron, as shown in the following diagram, a neuron works similar to a collector, wherein it collects signals from other neurons through dendrites. Once the signal becomes strong, the neuron sends out an electrical signal through thin strands known as axons to nearby neurons. At the end of this network, the synapse converts the signal activity into an excitation activity and activates the connected neurons. Brain neurons learn to send signals to different parts of the brain by changing the effectiveness of the synapse, similar to how some weights become close to zero for certain neurons in an artificial neural network:

There are a lot of theories to suggest that dense connections among neurons increase the ability of humans to learn. In turn, many neuroscientists believe that dense dendrite connectivity is created as the brain is used more through learning and stimulation. Hence, we become more intelligent as we learn more and more.

Though the human neuron has been the inspiration for creating artificial neural networks, there are several ways in which they are dissimilar. Researchers are trying to bridge these gaps by experimenting with different activation (excitation) functions and non-linear systems. Similar to how our brain has a collection of neurons that transmit and process the information received from our senses, a neural network also consists of layers (a group of neurons) that learns about tasks by transmitting information across layers. In certain cases, we can say an artificial neuron works in a similar way to a neuron present in our brain. Let's look at the following diagram:

As we can see in the preceding diagram, information flows through each connection, and each connection has a specific weight, which controls the flow of data. If we compare a human brain neuron's activity with artificial neural networks, we will see that whenever we create a neural network for a task, it is like creating a new brain neuron. If we look around us, we have already started relying on computers to make decisions, for example, in the case of credit card fraud, spam/non-spam emails, and recommendation systems. It's like we have created new brains for small tasks around us. Still, the question remains, what is the difference between human and artificial neural networks? Let's find out:

• One of the major differences is the amount of learning data required. For a neural network to learn, we need a lot of data, whereas a human brain can learn with less data. If we wish to have a neural network with a similar capacity to a human brain, we need to improve upon existing optimization algorithms.
• Another key difference is speed. Often, neural networks process data and information much more quickly than humans.

Machine learning is a program that, given a task (loss function), learns through experience (training data). With experience, that program learns to perform the given task to a desirable standard. During the 1960s, machine learning was majorly focused on creating different forms of data preprocessing filters. With the introduction of image filters, the focus then shifted toward computer vision, and major research work was undertaken in this domain during the 1990s and 2000s. After some stability in terms of traditional machine learning algorithms being developed, researchers moved to the probabilistic domain, as it became more promising with the introduction of high-dimensional data. Deep learning bloomed when it won the ImageNet Challenge in 2012, and has since taken on an important role in the field of data science.

Machine learning can be classified into two categories:

• Parametric: Learning is accomplished by using an algorithm to adapt the parameters in a mathematical or statistical model given training data, such as logistic regression, support vector machines, and neural networks.
• Nonparametric: Learning is accomplished by storing the training data (memorization) and performing some dimensionality reduction mappings, for example, k-nearest neighbor (kNN) and decision trees.

Machine learning and deep learning have revolutionized the computer science industry, but they have advantages and disadvantages. Some of the common challenges faced by our current approaches are as follows:

• Data gathering: Collecting sufficient relevant data for each category for machines to learn is laborious.
• Data labeling: Often, labeling data requires experts or is impossible due to privacy, safety, or ethical issues.
• Hardware constraints: Due to the large amount of data, as well as large parametric models, expensive hardware (GPUs and TPUs) is required to train them.
• Result analysis: Understanding the result is also a major challenge, though there are certain open source libraries that provide analysis parameters.

Apart from these challenges, machine learning also faces challenges in dealing with feature selection and higher-dimensional data.

In the next section, we will introduce one-shot learning and learn how it attempts to solve the challenges faced by machine learning and deep learning.

One-shot learning can be seen as an approach to train machines in a way that is similar to how humans learn. One-shot learning is an approach to learn a new task using limited supervised data with the help of strong prior knowledge. The first work published that resulted in high accuracy for the image classification problem dates back to the 2000s by Dr. Fei Fei Li—although, in recent years, researchers have made good progress tackling it through different deep learning architectures and optimization algorithms, such as matching networks, model agnostic meta-learning, and memory-augmented neural networks. One-shot learning has a lot of applications in several industries—the medical and manufacturing industries in particular. In medicine, we can use one-shot learning when there is limited data available, for example, when working with rare diseases; whereas in manufacturing, we can reduce man-made errors such as edge case manufacturing defects.

If we look into further discussion about how we can learn necessary information from a limited amount of data, we will realize that the human brain already has neurons trained to extract important information. For example, if a child has been taught that a spherical object is a ball, their brain also processes information about the ball's size and texture—also known as filters of the object. So, for any form of one-shot learning, we can say we need at least one of the following things:

• Previously trained filters and a pre-determined architecture
• A correct assumption of data distribution
• A definite form of taxonomy for information stored or collected

In certain cases, we observe that we can only have a very low level of feature extraction. In those scenarios, we can just rely on a nonparametric or probabilistic approach because, to learn parameters, we need a sufficient amount of data. Even if we somehow force a neural network to learn with hardly any data, it will result in overfitting.

In the next section, we will do a short coding exercise to see how, when we have a small dataset, a simple nonparametric kNN performs better than neural networks. Unfortunately, it probably wouldn't work very well in the real world, as we still have the problems of learning a good feature representation and choosing an appropriate distance function.

There are various approaches to solve one-shot learning. Roughly speaking, they can be organized into five main categories:

• Data augmentation methods
• Model-based methods
• Metrics-based methods
• Optimization-based methods
• Generative modeling-based methods

The following diagram shows the categories of one-shot learning:

Data augmentation is the most commonly used method in the deep learning community to add variations to data, increase data size, and balance data. It's achieved by adding some form of noise in the data. For instance, images might be scaled, translated, and rotated; whereas in a natural language processing task, there might be synonym replacement, random insertions, and random swaps.

Though data augmentation methods play a crucial role in preprocessing, we won't be covering that topic in this book. In this book, we will focus on algorithmic approaches of one-shot learning and how to implement them. We will also experiment with them on commonly used one-shot learning datasets such as the Omniglot dataset and Mini ImageNet.

In this section, we will set up a virtual environment for our coding exercise and questions using the following steps:

1. Clone the repository by going into the directory of your choice and running the following command in the Git Bash command line:

git clone https://github.com/Packt-Publishing/Hands-on-One-Shot-Learning.git

2. Go to the Chapter01 directory of the cloned repository:

cd Hands-on-One-Shot-Learning/Chapter01

3. Then, open a Terminal and use the following command to install Anaconda for Python, version 3.6 (https://docs.anaconda.com/anaconda/install/), and create a virtual environment:

conda create --name environment_name python=3.6

4. Activate the environment using the following command:

source activate environment_name

5. Install requirements.txt using the following command:

pip install -r requirements.txt

6. Run the following command to open Jupyter Notebook:

jupyter notebook

Now that we have set up the environment, let's go ahead with the coding exercise.

In this section, we will explore a basic one-shot learning approach. As humans, we have a hierarchical way of thinking. For example, if we see something unknown to us, we look for its similarity to objects we already know. Similarly, in this exercise, we will use a nonparametric kNN approach to find classes. We will also compare its performance to the basic neural network architecture.

In this exercise, we will compare kNN to neural networks where we have a small dataset. We will be using the iris dataset imported from the scikit-learn library.

To begin, we will first discuss the basics of kNN. The kNN classifier is a nonparametric classifier that simply stores the training data, D, and classifies each new instance using a majority vote over its set of k nearest neighbors, computed using any distance function. For a kNN, we need to choose the distance function, d, and the number of neighbors, k:

Follow these steps to compare kNN with a neural network:

1. Import all the libraries required for this exercise using the following code:

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, accuracy_score
from sklearn.model_selection import cross_val_score
from sklearn.neural_network import MLPClassifier

2. Import the iris dataset:

# import small dataset
iris = datasets.load_iris()
X = iris.data
y = iris.target

3. To ensure we are using a very small dataset, we will randomly choose 30 points and print them using the following code:

indices=np.random.choice(len(X), 30)
X=X[indices]
y=y[indices]
print (y)

This will be the resultant output:

[2 1 2 1 2 0 1 0 0 0 2 1 1 0 0 0 2 2 1 2 1 0 0 1 2 0 0 2 0 0]

4. To understand our features, we will try to plot them in 3D as a scatterplot:

from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(1, figsize=(20, 15))
ax = Axes3D(fig, elev=48, azim=134)
ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y,
         cmap=plt.cm.Set1, edgecolor='k', s = X[:, 3]*50)

for name, label in [('Virginica', 0), ('Setosa', 1), ('Versicolour', 2)]:
    ax.text3D(X[y == label, 0].mean(),
              X[y == label, 1].mean(),
              X[y == label, 2].mean(), name,
              horizontalalignment='center',
              bbox=dict(alpha=.5, edgecolor='w', facecolor='w'),size=25)

ax.set_title("3D visualization", fontsize=40)
ax.set_xlabel("Sepal Length [cm]", fontsize=25)
ax.w_xaxis.set_ticklabels([])
ax.set_ylabel("Sepal Width [cm]", fontsize=25)
ax.w_yaxis.set_ticklabels([])
ax.set_zlabel("Petal Length [cm]", fontsize=25)
ax.w_zaxis.set_ticklabels([])

plt.show()

The following plot is the output. As we can see in the 3D visualization, data points are usually found in groups:

5. To begin with, we will first split the dataset into training and testing sets using an 80:20 split. We will be using k=3 as the nearest neighbor:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
# Instantiate learning model (k = 3)
classifier = KNeighborsClassifier(n_neighbors=3)

# Fitting the model
classifier.fit(X_train, y_train)

# Predicting the Test set results
y_pred = classifier.predict(X_test)

cm = confusion_matrix(y_test, y_pred)

accuracy = accuracy_score(y_test, y_pred)*100
print('Accuracy of our model is equal ' + str(round(accuracy, 2)) + ' %.')

This will result in the following output:

Accuracy of our model is equal 83.33 %.

6. Initialize the hidden layers' sizes and the number of iterations:

mlp = MLPClassifier(hidden_layer_sizes=(13,13,13),max_iter=10)
mlp.fit(X_train,y_train)

7. We will predict our test dataset for both kNN and a neural network and then compare the two:

predictions = mlp.predict(X_test)

accuracy = accuracy_score(y_test, predictions)*100
print('Accuracy of our model is equal ' + str(round(accuracy, 2)) + ' %.')

The following is the resultant output:

Accuracy of our model is equal 50.0 %.

For our current scenario, we can see that the neural network is less accurate than the kNN. This could be due to a lot of reasons, including the randomness of the dataset, the choice of neighbors, and the number of layers. But if we run it enough times, we will observe that a kNN is more likely to give a better output as it always stores data points, instead of learning parameters as neural networks do. Therefore, a kNN can be called a one-shot learning method.

Deep learning has revolutionized the field of data science and it is still making progress, but there are still major industries that are yet to experience all of the advantages of deep learning, such as the medical and manufacturing industries. The zenith of human achievement will be to create a machine that can learn as humans do and that can become an expert in the same way humans can. Successful deep learning, though, usually comes with the prerequisite of having very large datasets to work from. Fortunately, this book focuses on architectures that can do away with this prerequisite.

In this chapter, we learned about the human brain and how the structure of an artificial neural network is close to the structure of our brain. We introduced the basic concepts of machine learning and deep learning, along with their challenges. We also discussed one-shot learning and its various types, and later experimented with the iris dataset to compare a parametric and nonparametric approach in a scarce data situation. Overall, we concluded that proper feature representation plays an important role in determining the efficiency of a machine learning model.

In the next chapter, we will learn about metrics-based one-shot learning methods and explore the feature extraction domain of one-shot learning algorithms.

• Why does a kNN work better than a newly trained artificial neural network for a one-shot learning task?
• What are nonparametric machine learning algorithms?
• Are decision trees a parametric or nonparametric algorithm?
• Experiment with other classification algorithms as a coding exercise and compare the results.