We have so many details that we can “perceive”, yet we seem to process them very efficiently. This phenomenon is pervasive across all sensory systems.

**Question:** How does the brain learn concepts efficiently from a small number of examples even though each example contains a huge amount of information?

## Easy Concept vs. Hard Concept

Some concepts seem to be easier to pick up than other concepts.

For example, we can learn a concept of ELEPHANT easily with only a small number of examples. It is easy to distinguish elephants from others because it has many features that stand out from other animals.

However, learning a concept of AFRICAN ELEPHANT seems to be more difficult. It will take a lot more examples until you figure out one of its distinguishing features (i.e. big ear).

Why is one concept more difficult to learn than others?

The number of (relevant) features do not seem to determine the difficulty of a concept.

Instead, the similarity of examples with the same label and dissimilarity of examples with different labels seem to play a key role -> **robustness **of a concept.

Recall that , a **PAC-learning** algorithm, after seeing examples , comes up with a hypothesis h(x) with probability 1- such that P(h(x) = l(x)) >= 1- .

Ideally, you don’t want to have to see many examples to learn.

## Learning Parity

Suppose and we have a “parity” concept: .

How many # of examples do we need to learn this concept (i.e. learning all )? (There are possible such concepts)

Assuming a **membership query model**, we only need to query n+1 times by flipping each query’s bit position and monitoring its effect on the parity:

**Query 1**: (1,0,1,1,1, … 0) -> 1

**Query 2**: (0,0,1,1,1, … 0) -> 0 (parity changed, first bit is relevant)

**Query 3**: (0,1,1,1,1, … 0) -> 0 (parity unchanged, second bit is irrelevant)

…

**Query N+1**: (0,1,0,0,0, … 1) -> … (DONE! all are learned)

Can we do better than n examples? **NO**!

Learning this concept can be represented as solving a system of linear equations:

…

We need n linearly independent equations to get a unique solution.

But what if we use less than n linearly independent examples?

For example, using n-2 linearly independent examples will find out all correct bits in Y except 2 positions, and will leave us with 4 “candidate” concepts.

Can we simply use any of 4 candidate concepts left? Does all 4 candidate concepts have similar accuracy since they only differ by at most 2 bits?

Suppose we have S, T, and (S, T are different in at least 1 bit).

Then, which means that you will be wrong half of the time (only as good as picking a random concept)!

## Learning Halfspaces

, iff f(x) = 1

**Question**: How many **distinct** W vectors (halfspaces) are there?

Clearly, , but it has a tighter bound:

A halfspace can pivot until it touches n points without changing its classification (n degrees of freedom):

**Theorem**: examples suffice for learning halfspaces from any distribution.

But these are still too many examples because it requires as many examples as dimensions (features). Can we do better?

## Attribute-Efficient Learning

A concept is defined by k relevant features out of n total features (k << n).

In this model, sample complexity goes down to .

But even if it reduces the number of examples required, the computational complexity is very high (there is no simple learning algorithm).

In fact, if a concept is a disjunction of k features, it is **NP-hard** to learn which k features are relevant from a set of examples.

## l-Robust Concepts

A concept C is -robust if

Sample complexity for learning a -robust concept is , which does not depend on the number of features!

But how does having a -sized gap help to reduce sample complexity? Also, does it come with a huge computational cost like attribute efficient learning?

A simple algorithm, **random projection**, can be used to reduce the dimensionality of examples while “preserving” a -robust concept.

## Random Projection

To project a given point x to a k-dimensional space (k < n), we first choose a n x k matrix R whose columns are random vectors .

The projection can be succinctly written as: .

Random projection is very simple to implement and “neuron-friendly” because it can be represented as a simple 1-layer neural network:

How do we choose each entry of matrix R $?

- [standard normal distribution with mean 0 and variance 1]
- [discrete distribution defined by with prob. 1/2 and with prob. 1/2]

Does random projection “preserve” a -robust concept?

**Theorem**: If , then with probability , which is -robust that can be learned with examples.

**Proof Idea**: Followings occur with high probability after random projection:

- For any pair of points and projections
- For each example :
- if , then
- if , then

**Lemma**: Given

As you increase target k, the probability it deviates from the expected length gets smaller! The lemma also works for many other distributions on the projection matrix.

## Algorithm for learning robust concepts

**Generic algorithm:**

- Since the target concept is robust, random projection of the examples to a much lower-dimensional subspace will “preserve” the concept
- In the lower-dimensional space, the number of examples and the time required to learn concepts are relatively small.

**-robust halfspaces:**

- Choose an n x k random matrix R by picking each entry indepedently from N(0,1) or U(-1,1).
- Obtain m examples from D and project them to using R.
- Run the Perceptron algorithm, which is guaranteed to terminate after at most iterations
- Output W.