Machine Learning researchers have a tough time agreeing on the best formulations for the problems they face. Even within the relatively well-defined setting of supervised learning, there are lots of ways to express the nature of the problem. At a very high level, we can express supervised learning as a meta-problem of the following form:

Given access to some process that hints at how quantities of type are related to quantities of type , construct a model that can accept an and return a in a way that is somewhat consistent with this process.

## Classification

One of the broad subcategories of supervised learning is **classification**. In a classification problem, we assume that is an element of . For simplicity, we will assume that is a vector in the space , which will either be or . There are a number of ways to characterize how is related to , but the simplest is to assume that there exists some joint probability distribution over from which samples are drawn. Given an algorithm that can accept some and return some , we can quantify its **error** relative to the distribution as . We will refer to such an algorithm as a **concept**.

Of course, there are many kinds of concepts, and even more ways to discover and construct them. We define a **concept class** to be a family of concepts. Many algorithms for supervised learning are concept class-specific, and operate essentially as search algorithms that explore the concept class space in order to find a concept with an acceptably low error.

- A simple concept class for the case that is the class of
**conjunctions**, expressed as vectors in . The prediction of the conjunction on the vector is - A simple concept class for the case that is the class of
**linear halfspaces**, expressed as tuples such that . The prediction of a linear halfspace on the vector is

One natural objective is to find the concept in the class with the minimum error relative to the distribution . However, this is usually too hard, and can be impossible in many cases (such as when the concept class is uncountably infinite). Instead, we will characterize the problem as one of finding a concept that has error less than , where is the minimum error relative to the distribution of any concept and is a parameter to the algorithm. In order to find this concept, we will allow our search algorithm access to some kind of **oracle** that gives us information about samples drawn from . Two natural kinds of oracles are:

- An
**example oracle**, that generates samples from - A
**membership oracle**that accepts and generates a sample in from conditioned on

Generally we assume that both of these oracles are deterministic when conditioned on . That is, for any the membership oracle will generate the same each time it is called with that , and once we draw from the example oracle we will not draw (and vice versa). This assumption is more realistic than treating each query as completely independent, since in practice it is often challenging to get multiple independent labellings for a particular example. Since both of these oracles depend on the randomized process of drawing samples from , we generally allow our search algorithm to fail with some probability , where is a parameter to the search algorithm. We will see examples of other oracles that do not explicitly rely on drawing samples from later.

In the **Agnostic Learning** framework, we make no further assumptions about and simply aim to solve the search problem described above. We typically allow our search algorithm to run longer or sample the oracles more times when and/or are small, the space has more dimensions, and/or the concepts in are large (require more bits to express). We refer to a concept class as **Agnostically Learnable** if we can efficiently solve this problem for any distribution .

It is important to note that this is a very natural model of learning. In practice, we rarely have the luxury of making any assumptions about the true distribution over which our data is drawn. For example, a computer vision researcher who builds a model to classify images or a natural language processing researcher who constructs a system to detect hate speech are performing Agnostic Learning. The distributions of natural images and text are extraordinarily complicated, and most assumptions about them being equivalent to a well-understood closed-form probability distribution are likely to be incorrect.

However, pure Agnostic Learning is intractable for even simple concept classes, such as the conjunction class and linear halfspace class described above. For this reason, most mathematical insights in Computational Learning Theory rely on assumptions over . One of the least restrictive assumptions is that the marginal distribution of over is a member of some well understood class of distributions. This is the **Distribution-specific Agnostic Learning** framework. Just this assumption alone significantly simplifies the problem. For example, if we assume that is the spherical normal distribution , then we can efficiently learn the concept class of linear halfspaces.

It is worth noting that in both Agnostic Learning and Distribution-specific Agnostic Learning, search algorithms that have access to just the example oracle are equally powerful as search algorithms that have access to both and the membership oracle . In order for the membership oracle to increase the power of the search algorithm, we need to make further assumptions about the relationship that defines between and .

### PAC Learning

For example, one significant simplification we can make is to assume that for some concept class , there exists some truth concept such that . When this is the case, we will write as . This is the **PAC**, or “Probably Approximately Correct” framework. We refer to the concept class as being **PAC-learnable** if for any truth concept , any associated distribution , and any error parameter , with probability we can use an example oracle to efficiently find a concept such that . There are a number of variations of PAC learning, which we will go through below.

#### Proper vs Improper PAC Learning

In the **proper PAC learning** framework, we require that is from the same concept class as . Both the concept class of linear halfspaces and the concept class of conjunctions are **properly PAC-learnable** (or just PAC-learnable). In contrast, in the **improper PAC learning** framework, we allow to be from a different concept class than the target concept . Intuitively, we would expect that there are concept classes that are **improperly PAC-learnable**, but are not PAC-learnable. This turns out to be the case. One reason for this is that some non-properly PAC-learnable concept classes are subsets of properly PAC-learnable concept classes. For example, although the concept class of boolean formulas that we can express as a disjunction of 3 conjunctions (**3-Term DNF**) is not properly PAC-learnable, the larger concept class of boolean formulas that we can express as conjunctions of 3-term disjunctions (**3-CNF**) is properly PAC-learnable. Since the concept class of 3-CNF formulas contains the concept class of 3-Term DNF formulas, we can use the algorithm for properly learning 3-CNF to learn an approximation to any in the 3-Term DNF concept class. This implies that 3-Term DNF is improperly PAC-learnable.

#### Weak vs Strong PAC Learning

Another variation of PAC learning is **weak PAC learning**, where we relax the requirement that the generated concept has error less than any arbitrary and instead only require it to have error less than some fixed . We refer to non-weak PAC learning as **strong PAC learning** (or just PAC learning). Although we may expect that there are concept classes that are weakly PAC-learnable but not strongly PAC-learnable, this is actually false. The reason for this is that there exist Boosting algorithms that can transform a weak PAC learning algorithm into a strong PAC learning algorithm. Boosting algorithms work by repeatedly running multiple copies of the weak learning algorithm and intelligently averaging the outputs. Since these algorithms can run efficiently, any concept class that is weakly PAC-learnable is also PAC-learnable.

#### PAC Learning with Membership Queries

Yet another variation of PAC learning is **PAC learning with membership queries**, where in addition to the example oracle we allow the learning algorithm access to the membership oracle that accepts and produces its label according to the target concept . Learning algorithms that have access to are (most likely) capable of learning concept classes that algorithms without this access cannot learn. The reason for this is that algorithms with access to a membership oracle can directly probe their “areas of uncertainty” in the space rather than being at the mercy of the samples drawn from . One example of a concept class that is PAC-learnable with membership queries but is not known to be PAC-learnable without membership queries is the concept class of **monotone-DNF** formulas, or boolean formulas that can be expressed as disjunctions of conjunctions of positive literals.

For mathematical convenience, researchers sometimes use the **EQ-MQ** framework as an alternative to PAC learning with membership queries. In this framework, we allow the algorithm access to the membership oracle as well as an **equivalence oracle** that accepts a candidate concept and either returns “Yes” if the candidate concept is exactly equivalent to the target concept or a counterexample if it is not. Instead of expecting the learning algorithm to find a concept such that with probability , we instead require the algorithm to find the exact target concept . It is not too hard to see that any concept class that is EQ-MQ learnable is also PAC-learnable with membership queries (if we allow for a small probability of error, we can translate an EQ-MQ learning algorithm into a PAC learning algorithm by replacing the calls to with a sufficiently large number of calls to ). It is also easy to see that the converse is not true. For example, a concept class of uncountable size (such as the class of linear halfspaces) could never be exactly learnable.

#### Noise

One of the fundamental differences between all of the variants of PAC learning that we have described and the more realistic scenario of Agnostic learning is the very strong assumption on that there exists some truth concept such that . It is worth considering how we can relax this assumption without reverting to the intractability of Agnostic Learning. One simple way to do this is to assume that we instead observe the noisy distribution such that . Of course, the structure of this distribution is critical. In the **PAC Learning with Random Classification Noise** model of learning we allow the learning algorithm access to the noisy example oracle that generates samples from . Importantly, we keep the assumption that is deterministic when conditioned on X, and we still measure the algorithm’s error with respect to the noiseless distribution. That is, we still require the learning algorithm to find a such that with probability .

It is notable that we generally assume that is not dependent on (i.e. the noise is independent for each X). This significantly simplifies the problem, but it severely limits the practical applications of the framework. For example, there are many cases where a simple concept class may approximate some natural phenomena reasonably well, but where the errors are highly dependent on . For example, although a multidimensional linear halfspace may reasonably approximate a bank’s loan approval behavior, there are nonlinear effects, such as changes in how credit history is treated for higher net worth clients, that are decidedly not independent of .

However, even when we assume that the noise is independent, there are concept classes that are PAC-learnable but not PAC-learnable with random classification noise. For example, although the concept class of parity functions defined by subsets of boolean literals is PAC-learnable, it is widely believed not to be PAC-learnable with random classification noise. This makes intuitive sense: since the output of a parity function depends on all of the elements in the subset of boolean literals that defines it, an algorithm for learning parity functions in the face of noise will need to operate on a subset basis rather than a per-literal basis. Since there are exponentially many subsets, this makes efficient learning challenging.

Like PAC learning with membership queries, there exists an alternative framework that we can use to reason about PAC learning with random classification noise. In the **SQ** framework, we allow the learning algorithm access to only a **statistical query oracle** that can provide estimates of the expected values of random variables defined over . It is not hard to see that any concept class that is SQ-learnable is also PAC-learnable with random classification noise. Given access to a noisy example oracle , we can simulate a query to by drawing many examples from and computing an empirical estimate of the target expected value.

## Regression

Another broad subcategory of supervised learning is **regression**. In a regression problem, we assume that is an element of . We generally also assume that is an element of and that there exists some joint probability distribution over from which samples are drawn.

Like with classification, there are many ways to formulate regression problems based on applying different assumptions to . One of the simplest formulations is as the following optimization problem: For some set of functions and some “loss function” , find the function that minimizes . Let’s note that if we set our loss function and make the assumption that there exists some true target function such that , then this is equivalent to minimizing .

Of course, in order to minimize with classical optimization techniques, we will first need to approximate it. Given an example oracle from which we can draw samples , we can approximate this expectation with the expression . The quality of this estimate will depend on the size of , the complexity of and the expressiveness of . Depending on these factors, there are a wide range of techniques that we can use to find the that minimizes (or nearly minimizes) this estimate, including closed form optimization, gradient descent, and the method of Lagrange multipliers.

## Resources

Most of the content in this post is from An Introduction to Computational Learning Theory by Michael J. Kearns. Some content is also drawn from Toward Efficient Agnostic Learning, A theory of the learnable, and Convex Optimization: Algorithms and Complexity,