|The Fast Fourier Transform,
and a Noisy Signal
|Bezier Curves and Picasso||Computing Homology||Probably Approximately
Correct – A Formal Theory
I recently wrapped up a fun paper with my coauthors Ben Fish, Adam Lelkes, Lev Reyzin, and Gyorgy Turan in which we analyzed the computational complexity of a model of the popular MapReduce framework. Check out the preprint on the arXiv.
As usual I’ll give a less formal discussion of the research here, and because the paper is a bit more technically involved than my previous work I’ll be omitting some of the more pedantic details. Our project started after Ben Moseley gave an excellent talk at UI Chicago. He presented a theoretical model of MapReduce introduced by Howard Karloff et al. in 2010, and discussed his own results on solving graph problems in this model, such as graph connectivity. You can read Karloff’s original paper here, but we’ll outline his model below.
Basically, the vast majority of the work on MapReduce has been algorithmic. What I mean by that is researchers have been finding more and cleverer algorithms to solve problems in MapReduce. They have covered a huge amount of work, implementing machine learning algorithms, algorithms for graph problems, and many others. In Moseley’s talk, he posed a question that caught our eye:
Is there a constant-round MapReduce algorithm which determines whether a graph is connected?
After we describe the model below it’ll be clear what we mean by “solve” and what we mean by “constant-round,” but the conjecture is that this is impossible, particularly for the case of sparse graphs. We know we can solve it in a logarithmic number of rounds, but anything better is open.
In any case, we started thinking about this problem and didn’t make much progress. To the best of my knowledge it’s still wide open. But along the way we got into a whole nest of more general questions about the power of MapReduce. Specifically, Karloff proved a theorem relating MapReduce to a very particular class of circuits. What I mean is he proved a theorem that says “anything that can be solved in MapReduce with so many rounds and so much space can be solved by circuits that are yae big and yae complicated, and vice versa.
But this question is so specific! We wanted to know: is MapReduce as powerful as polynomial time, our classical notion of efficiency (does it equal P)? Can it capture all computations requiring logarithmic space (does it contain L)? MapReduce seems to be somewhere in between, but it’s exact relationship to these classes is unknown. And as we’ll see in a moment the theoretical model uses a novel communication model, and processors that never get to see the entire input. So this led us to a host of natural complexity questions:
- What computations are possible in a model of parallel computation where no processor has enough space to store even one thousandth of the input?
- What computations are possible in a model of parallel computation where processor’s can’t request or send specific information from/to other processors?
- How the hell do you prove that something can’t be done under constraints of this kind?
- How do you measure the increase of power provided by giving MapReduce additional rounds or additional time?
These questions are in the domain of complexity theory, and so it makes sense to try to apply the standard tools of complexity theory to answer them. Our paper does this, laying some brick for future efforts to study MapReduce from a complexity perspective.
In particular, one of our theorems is the following:
Theorem: Any problem requiring sublogarithmic space can be solved in MapReduce in two rounds.
This theorem is nice for two reasons. First is it’s constructive. If you give me a problem and I know it classically takes less than logarithmic space, then this gives an automatic algorithm to implement it in MapReduce, and if you were so inclined you could even automate the process of translating a classical algorithm to a MapReduce algorithm (it’s not pretty, but it’s possible).
Our other results are a bit more esoteric. We relate the questions about MapReduce to old, deep questions about computations that have simultaneous space and time bounds. In the end we give a (conditional, nonconstructive) answer to question 4 above, which I’ll sketch without getting too deep in the details.
So let’s start with the model of Karloff et al., which they named “MRC” for MapReduce Class.
The MRC Model of Karloff et al.
MapReduce is a programming paradigm which is intended to make algorithm design for distributed computing easier. Specifically, when you’re writing massively distributed algorithms by hand, you spend a lot of time and effort dealing with really low-level questions. Like, what do I do if a processor craps out in the middle of my computation? Or, what’s the most efficient way to broadcast a message to all the processors, considering the specific topology of my network layout means the message will have to be forwarded? Note these are questions that have nothing to do with the actual problem you’re trying to solve.
So the designers of MapReduce took a step back, analyzed the class of problems they were most often trying to solve (turns out, searching, sorting, and counting), and designed their framework to handle all of the low-level stuff automatically. The catch is that the algorithm designer now has to fit their program into the MapReduce paradigm, which might be hard.
In designing a MapReduce algorithm, one has to implement two functions: a mapper and a reducer. The mapper takes a list of key-value pairs, and applies some operation to each element independently (just like the map function in most functional programming languages). The reducer takes a single key and a list of values for that key, and outputs a new list of values with the same key. And then the MapReduce protocol iteratively applies mappers and reducers in rounds to the input data. There are a lot of pictures of this protocol on the internet. Here’s one
An interesting part of this protocol is that the reducers never get to communicate with each other, except indirectly through the mappers in the next round. MapReduce handles the implied grouping and message passing, as well as engineering issues like fault-tolerance and load balancing. In this sense, the mappers and reducers are ignorant cogs in the machine, so it’s interesting to see how powerful MapReduce is.
The model of Karloff, Suri, and Vassilvitskii is a relatively straightforward translation of this protocol to mathematics. They make a few minor qualifications, though, the most important of which is that they encode a bound on the total space used. In particular, if the input has size , they impose that there is some for which every reducer uses space . Moreover, the number of reducers in any round is also bounded by .
We can formalize all of this with a few easy definitions.
Definition: An input to a MapReduce algorithm is a list of key-value pairs of total size .
For binary languages (e.g., you give me a binary string and you want to know if there are an odd number of 1’s), we encode a string as the list . This won’t affect any of our space bounds, because the total blowup from to is logarithmic.
Definition: A mapper is a Turing machine which accepts as input a single key-value pair and produces as output a list of key-value pairs .
Definition: A reducer is a Turing machine which accepts as input a key and a list of values and produces as output the same key and a new list of values .
Now we can describe the MapReduce protocol, i.e. what a program is and how to run it. I copied this from our paper because the notation is the same so far.
All we’ve done here is just describe the MapReduce protocol in mathematics. It’s messier than it is complicated. The last thing we need is the space bounds.
Definition: A language is in if there is a constant and a sequence of mappers and reducers such that for all the following is satisfied:
- Letting and , accepts if and only if .
- For all , use space and time.
- Each outputs keys in round .
To be clear, the first argument to is the round bound, and the second argument is the time bound. The last point implies the bound on the number of processors. Since we are often interested in a logarithmic number of rounds, we can define
So we can restate the question from the beginning of the post as,
Is graph connectivity in ?
Here there’s a bit of an issue with representation. You have to show that if you’re just given a binary string representing a graph, that you can translate that into a reasonable key-value description of a graph in a constant number of rounds. This is possible, and gives evidence that the key-value representation is without loss of generality for all intents and purposes.
A Pedantic Aside
If our goal is to compare MRC with classes like polynomial time (P) and logarithmic space (L), then the definition above has a problem. Specifically the definition above allows one to have an infinite list of reducers, where each one is potentially different, and the actual machine that is used depends on the input size. In formal terminology, MRC as defined above is a nonuniform model of computation.
Indeed, we give a simple proof that this is a problem by showing any unary language is in (which is where many of the MRC algorithms in recent years have been). For those who don’t know, this is a problem because you can encode versions of the Halting problem as a unary language, and the Halting problem is undecidable.
While this level of pedantry might induce some eye-rolling, it is necessary in order to make statements like “MRC is contained in P.” It’s simply not true for the nonuniform model above. To fix this problem we refined the MRC model to a uniform version. The details are not trivial, but also not that interesting. Check out the paper if you want to know exactly how we do it. It doesn’t have that much of an effect on the resulting analysis. The only important detail is that now we’re representing the entire MRC machine as a single Turing machine. So now, unlike before, any MRC machine can be written down as a finite string, and there are infinitely many strings representing a given MRC machine. We call our model MRC, and Karloff’s model nonuniform MRC.
You can also make randomized versions of MRC, but we’ll stick to the deterministic version here.
Now we can sketch the proof that sublogarithmic space is in . In fact, the proof is simpler for regular languages (equivalent to constant space algorithms) being in . The idea is as follows:
A regular language is one that can be decided by a DFA, say (a graph representing state transitions as you read a stream of bits). And the DFA is independent of the input size, so every mapper and reducer can have it encoded into them. Now what we’ll do is split the input string up in contiguous chunks of size among the processors (mappers can do this just fine). Now comes the trick. We have each reducer compute, for each possible state in , what the ending state would be if the DFA had started in state after processing their chunk of the input. So the output of reducer would be an encoding of a table of the form:
And the result would be a lookup table of intermediate computation results. So each reducer outputs their part of the table (which has constant size). Since there are only reducers, all of the table pieces can fit on a single reducer in the second round, and this reducer can just chain the functions together from the starting state and output the answer.
The proof for sublogarithmic space has the same structure, but is a bit more complicated because one has to account for the tape of a Turing machine which has size . In this case, you split up the tape of the Turing machine among the processors as well. And then you have to keep track of a lot more information. In particular, each entry of your function has to look like
“if my current state is A and my tape contents are B and the tape head starts on side C of my chunk of the input”
“the next time the tape head would leave my chunk, it will do so on side C’ and my state will be A’ and my tape contents will be B’.”
As complicated as it sounds, the size of one of these tables for one reducer is still less than for some . And so we can do the same trick of chaining the functions together to get the final answer. Note that this time the chaining will be adaptive, because whether the tape head leaves the left or right side will determine which part of the table you look at next. And moreover, we know the chaining process will stop in polynomial time because we can always pick a Turing machine to begin with that will halt in polynomial time (i.e., we know that L is contained in P).
The size calculations are also just large enough to stop us from doing the same trick with logarithmic space. So that gives the obvious question: is ? The second part of our paper shows that even weaker containments are probably very hard to prove, and they relate questions about MRC to the problem of L vs P.
This part of the paper is where we go much deeper into complexity theory than I imagine most of my readers are comfortable with. Our main theorem looks like this:
Theorem: Assume some conjecture is true. Then for every , there is are bigger such that the following hold:
This is a kind of hierarchy theorem that one often likes to prove in complexity theory. It says that if you give MRC enough extra rounds or time, then you’ll get strictly more computational power.
The conjecture we depend on is called the exponential time hypothesis (ETH), and it says that the 3-SAT problem can’t be solved in time for any . Actually, our theorem depends on a weaker conjecture (implied by ETH), but it’s easier to understand our theorems in the context of the ETH. Because 3-SAT is this interesting problem: we believe it’s time-intensive, and yet it’s space efficient because we can solve it in linear space given time. This time/space tradeoff is one of the oldest questions in all of computer science, but we still don’t have a lot of answers.
For instance, define to the the class of languages that can be decided by Turing machines that have simultaneous bounds of time and space. For example, we just said that , and there is a famous theorem that says that SAT is not in ; apparently this is the best we know. So clearly there are some very basic unsolved problems about TISP. An important one that we address in our paper is whether there are hierarchies in TISP for a fixed amount of space. This is the key ingredient in proving our hierarchy theorem for MRC. In particular here is an open problem:
Conjecture: For every two integers , the classes and are different.
We know this is true of time and space separately, i.e., that and . but for TISP we only know that you get more power if you increase both parameters.
So we prove a theorem that address this, but falls short in two respects: it depends on a conjecture like ETH, and it’s not for every .
Theorem: Suppose ETH holds, then for every there is a for which .
In words, this suggests that there are problems that need both time and space, but can be solved with linear space if you allow enough extra time. Since , this gives us the hierarchy we wanted.
To prove this we take 3-SAT and give it exponential padding so that it becomes easy enough to do in polynomial TISP (and it still takes linear space, in fact sublinear), but not so easy that you can do it in time. It takes some more work to get from this TISP hierarchy to our MRC hierarchy, but the details are a bit much for this blog. One thing I’d like to point out is that we prove that statements that are just about MRC have implications beyond MapReduce. In particular, the last corollary of our paper is the following.
Corollary: If , then L is different from P.
In other words, if you’re afforded a polynomial number of rounds in MRC, then showing that constant time per round is weaker than polynomial time is equivalently hard to separating L from P. The theorem is true because, as it turns out, , by simulating one step of a TM across polynomially many rounds. The proof is actually not that complicated (and doesn’t depend on ETH at all), and it’s a nice demonstration that studying MRC can have implications beyond parallel computing.
The other side of the coin is also interesting. Our first theorem implies the natural question of whether . We’d like to say that this would imply the separation of L from P, but we don’t quite get that. In particular, we know that
But at the same time we could live in a world where
It seems highly unlikely, but to the best of our knowledge none of our techniques prove this is not the case. If we could rule this out, then we could say that implies the separation of L and P. And note this would not depend on any conjectures.
Our paper has a list of open problems at the end. My favorite is essentially: how do we prove better lower bounds in MRC? In particular, it would be great if we could show that some problems need a lot of rounds simply because the communication model is too restrictive, and nobody has true random access to the entire input. For example, this is why we think graph connectivity needs a logarithmic number of rounds. But as of now nobody really knows how to prove it, and it seems like we’ll need some new and novel techniques in order to do it. I only have the wisps of ideas in that regard, and it will be fun to see which ones pan out.
Until next time!
Leonardo da Vinci’s Mona Lisa is one of the most famous paintings of all time. And there has always been a discussion around her enigmatic smile. He used a trademark Renaissance technique called sfumato, which involves many thin layers of glaze mixed with subtle pigments. The striking result is that when you look directly at Mona Lisa’s smile, it seems to disappear. But when you look at the background your peripherals see a smiling face.
One could spend decades studying the works of these masters from various perspectives, but if we want to hone in on the disappearing nature of that smile, mathematics can provide valuable insights. Indeed, though he may not have known the relationship between his work and da Vinci’s, hundreds of years later Salvador Dali did the artist’s equivalent of mathematically isolating the problem with his painting, “Gala Contemplating the Mediterranean Sea.”
Here you see a woman in the foreground, but step back quite far from the picture and there is a (more or less) clear image of Abraham Lincoln. Here the question of gaze is the blaring focus of the work. Now of course Dali and da Vinci weren’t scribbling down equations and computing integrals; their artistic expression was much less well-defined. But we the artistically challenged have tools of our own: mathematics, science, and programming.
In 2006 Aude Oliva, Antonio Torralba, and Philippe. G. Schyns used those tools to merge the distance of Dali and the faded smiles of da Vinci into one cohesive idea. In their 2006 paper they presented the notion of a “hybrid image,” presented below.
If you look closely, you’ll see three women, each of which looks the teensiest bit strange, like they might be trying to suppress a smile, but none of them are smiling. Blur your eyes or step back a few meters, and they clearly look happy. The effect is quite dramatic. At the risk of being overly dramatic, these three women are literally modern day versions of Mona Lisa, the “Mona Lisas of Science,” if you will.
Another, perhaps more famous version of their technique, since it was more widely publicized, is their “Marilyn Einstein,” which up close is Albert Einstein and from far away is Marilyn Monroe.
This one gets to the heart of the question of what the eye sees at close range versus long range. And it turns out that you can address this question (and create brilliant works of art like the ones above) with some basic Fourier analysis.
Intuitive Fourier analysis (and references)
The basic idea of Fourier analysis is the idea that smooth functions are hard to understand, and realization of how great it would be if we could decompose them into simpler pieces. Decomposing complex things into simpler parts is one of the main tools in all of mathematics, and Fourier analysis is one of the clearest examples of its application.
In particular, the things we care about are functions with specific properties I won’t detail here like “smoothness” and “finiteness.” And the building blocks are the complex exponential functions
where can be any integer. If you have done some linear algebra (and ignore this if you haven’t), then I can summarize the idea succinctly by saying the complex exponentials form an orthonormal basis for the vector space of square-integrable functions.
Back in colloquial language, what the Fourier theorem says is that any function of the kind we care about can be broken down into (perhaps infinitely many) pieces of this form called Fourier coefficients (I’m abusing the word “coefficient” here). The way it’s breaking down is also pleasingly simple: it’s a linear combination. Informally that means you’re just adding up all the complex exponentials with specific weights for each one. Mathematically, the conversion from the function to its Fourier coefficients is called the Fourier transform, and the set of all Fourier coefficients together is called the Fourier spectrum. So if you want to learn about your function , or more importantly modify it in some way, you can inspect and modify its spectrum instead. The reason this is useful is that Fourier coefficients have very natural interpretations in sound and images, as we’ll see for the latter.
We wrote and the complex exponential as a function of one real variable, but you can do the same thing for two variables (or a hundred!). And, if you’re willing to do some abusing and ignore the complexness of complex numbers, then you can visualize “complex exponentials in two variables” as images of stripes whose orientation and thickness correspond to two parameters (i.e., the in the offset equation becomes two coefficients). The video below shows how such complex exponentials can be used to build up an image of striking detail. The left frame shows which complex exponential is currently being added, and the right frame shows the layers all put together. I think the result is quite beautiful.
This just goes to show how powerful da Vinci’s idea of fine layering is: it’s as powerful as possible because it can create any image!
Now for digital images like the one above, everything is finite. So rather than have an infinitely precise function and a corresponding infinite set of Fourier coefficients, you get a finite list of sampled values (pixels) and a corresponding grid of Fourier coefficients. But the important and beautiful theorem is, and I want to emphasize how groundbreakingly important this is:
If you give me an image (or any function!) I can compute the decomposition very efficiently.
And the same theorem lets you go the other way: if you give me the decomposition, I can compute the original function’s samples quite easily. The algorithm to do this is called the Fast Fourier transform, and if any piece of mathematics or computer science has a legitimate claim to changing the world, it’s the Fast Fourier transform. It’s hard to pinpoint specific applications, because the transform is so ubiquitous across science and engineering, but we definitely would not have cell phones, satellites, internet, or electronics anywhere near as small as we do without the Fourier transform and the ability to compute it quickly.
Constructing hybrid images is one particularly nice example of manipulating the Fourier spectrum of two images, and then combining them back into a single image. That’s what we’ll do now.
As a side note, by the nature of brevity, the discussion above is a big disservice to the mathematics involved. I summarized and abused in ways that mathematicians would object to. If you want to see a much better treatment of the material, this blog has a long series of posts developing Fourier transforms and their discrete analogues from scratch. See our four primers, which lead into the main content posts where we implement the Fast Fourier transform in Python and use it to apply digital watermarks to an image. Note that in those posts, as in this one, all of the materials and code used are posted on this blog’s Github page.
High and low frequencies
For images, interpreting ranges of Fourier coefficients is easy to do. You can imagine the coefficients lying on a grid in the plane like so:
Each dot in this grid corresponds to how “intense” the Fourier coefficient is. That is, it’s the magnitude of the (complex) coefficient of the corresponding complex exponential. Now the points that are closer to the origin correspond informally to the broad, smooth changes in the image. These are called “low frequency” coefficients. And points that are further away correspond to sharp changes and edges, and are likewise called “high frequency” components. So the if you wanted to “hybridize” two images, you’d pick ones with complementary intensities in these regions. That’s why Einstein (with all his wiry hair and wrinkles) and Monroe (with smooth features) are such good candidates. That’s also why, when we layered the Fourier components one by one in the video from earlier, we see the fuzzy shapes emerge before the fine details.
Moreover, we can “extract” the high frequency Fourier components by simply removing the low frequency ones. It’s a bit more complicated than that, since you want the transition from “something” to “nothing” to be smooth in sone sense. A proper discussion of this would go into sampling and the Nyquist frequency, but that’s beyond the scope of this post. Rather, we’ll just define a family of “filtering functions” without motivation and observe that they work well.
Definition: The Gaussian filter function with variance and center is the function
It looks like this
In particular, at zero the function is 1 and it gradually drops to zero as you get farther away. The parameter controls the rate at which it vanishes, and in the picture above the center is set to .
Now what we’ll do is take our image, compute its spectrum, and multiply coordinatewise with a certain Gaussian function. If we’re trying to get rid of high-frequency components (called a “low-pass filter” because it lets the low frequencies through), we can just multiply the Fourier coefficients directly by the filter values , and if we’re doing a “high-pass filter” we multiply by .
Before we get to the code, here’s an example of a low-pass filter. First, take this image of Marilyn Monroe
Now compute its Fourier transform
Apply the low-pass filter
And reverse the Fourier transform to get an image
In fact, this is a common operation in programs like photoshop for blurring an image (it’s called a Gaussian blur for obvious reasons). Here’s the python code to do this. You can download it along with all of the other resources used in making this post on this blog’s Github page.
import numpy from numpy.fft import fft2, ifft2, fftshift, ifftshift from scipy import misc from scipy import ndimage import math def makeGaussianFilter(numRows, numCols, sigma, highPass=True): centerI = int(numRows/2) + 1 if numRows % 2 == 1 else int(numRows/2) centerJ = int(numCols/2) + 1 if numCols % 2 == 1 else int(numCols/2) def gaussian(i,j): coefficient = math.exp(-1.0 * ((i - centerI)**2 + (j - centerJ)**2) / (2 * sigma**2)) return 1 - coefficient if highPass else coefficient return numpy.array([[gaussian(i,j) for j in range(numCols)] for i in range(numRows)]) def filterDFT(imageMatrix, filterMatrix): shiftedDFT = fftshift(fft2(imageMatrix)) filteredDFT = shiftedDFT * filterMatrix return ifft2(ifftshift(filteredDFT)) def lowPass(imageMatrix, sigma): n,m = imageMatrix.shape return filterDFT(imageMatrix, makeGaussianFilter(n, m, sigma, highPass=False)) def highPass(imageMatrix, sigma): n,m = imageMatrix.shape return filterDFT(imageMatrix, makeGaussianFilter(n, m, sigma, highPass=True)) if __name__ == "__main__": marilyn = ndimage.imread("marilyn.png", flatten=True) lowPassedMarilyn = lowPass(marilyn, 20) misc.imsave("low-passed-marilyn.png", numpy.real(lowPassedMarilyn))
The first function samples the values from a Gaussian function with the specified parameters, discretizing the function and storing the values in a matrix. Then the
filterDFT function applies the filter by doing coordinatewise multiplication (note these are all numpy arrays). We can do the same thing with a high-pass filter, producing the edgy image below
And if we compute the average of these two images, we basically get back to the original.
So the only difference between this and a hybrid image is that you take the low-passed part of one image and the high-passed part of another. Then the art is in balancing the parameters so as to make the averaged image look right. Indeed, with the following picture of Einstein and the above shot of Monroe, we can get a pretty good recreation of the Oliva-Torralba-Schyns piece. I think with more tinkering it could be even better (I did barely any centering/aligning/resizing to the original images).
And here’s the code for it
def hybridImage(highFreqImg, lowFreqImg, sigmaHigh, sigmaLow): highPassed = highPass(highFreqImg, sigmaHigh) lowPassed = lowPass(lowFreqImg, sigmaLow) return highPassed + lowPassed
Interestingly enough, doing it in reverse doesn’t give quite as pleasing results, but it still technically works. So there’s something particularly important that the high-passed image does have a lot of high-frequency components, and vice versa for the low pass.
You can see some of the other hybrid images Oliva et al constructed over at their web gallery.
How can we take this idea further? There are a few avenues I can think of. The most obvious one would be to see how this extends to video. Could one come up with generic parameters so that when two videos are hybridized (frame by frame, using this technique) it is only easy to see one at close distance? Or else, could we apply a three-dimensional transform to a video and modify that in some principled way? I think one would not likely find anything astounding, but who knows?
Second would be to look at the many other transforms we have at our disposal. How does manipulating the spectra of these transforms affect the original image, and can you make images that are hybridized in senses other than this one?
And finally, can we bring this idea down in dimension to work with one-dimensional signals? In particular, can we hybridize music? It could usher in a new generation of mashup songs that sound different depending on whether you wear earmuffs :)
Until next time!
So far our discussion of learning theory has been seeing the definition of PAC-learning, tinkering with it, and seeing simple examples of learnable concept classes. We’ve said that our real interest is in proving big theorems about what big classes of problems can and can’t be learned. One major tool for doing this with PAC is the concept of VC-dimension, but to set the stage we’re going to prove a simpler theorem that gives a nice picture of PAC-learning when your hypothesis class is small. In short, the theorem we’ll prove says that if you have a finite set of hypotheses to work with, and you can always find a hypothesis that’s consistent with the data you’ve seen, then you can learn efficiently. It’s obvious, but we want to quantify exactly how much data you need to ensure low error. This will also give us some concrete mathematical justification for philosophical claims about simplicity, and the theorems won’t change much when we generalize to VC-dimension in a future post.
The Chernoff bound
One tool we will need in this post, which shows up all across learning theory, is the Chernoff-Hoeffding bound. We covered this famous inequality in detail previously on this blog, but the part of that post we need is the following theorem that says, informally, that if you average a bunch of bounded random variables, then the probability this average random variable deviates from its expectation is exponentially small in the amount of deviation. Here’s the slightly simplified version we’ll use:
Theorem: Let be independent random variables whose values are in the range . Call , , and . Then for all ,
One nice thing about the Chernoff bound is that it doesn’t matter how the variables are distributed. This is important because in PAC we need guarantees that hold for any distribution generating data. Indeed, in our case the random variables above will be individual examples drawn from the distribution generating the data. We’ll be estimating the probability that our hypothesis has error deviating more than , and we’ll want to bound this by , as in the definition of PAC-learning. Since the amount of deviation (error) and the number of samples () both occur in the exponent, the trick is in balancing the two values to get what we want.
Realizability and finite hypothesis classes
Let’s recall the PAC model once more. We have a distribution generating labeled examples , where is an unknown function coming from some concept class . Our algorithm can draw a polynomial number of these examples, and it must produce a hypothesis from some hypothesis class (which may or may not contain ). The guarantee we need is that, for any , the algorithm produces a hypothesis whose error on is at most , and this event happens with probability at least . All of these probabilities are taken over the randomness in the algorithm’s choices and the distribution , and it has to work no matter what the distribution is.
Let’s introduce some simplifications. First, we’ll assume that the hypothesis and concept classes and are finite. Second, we’ll assume that , so that you can actually hope to find a hypothesis of zero error. This is called realizability. Later we’ll relax these first two assumptions, but they make the analysis a bit cleaner. Finally, we’ll assume that we have an algorithm which, when given labeled examples, can find in polynomial time a hypothesis that is consistent with every example.
These assumptions give a trivial learning algorithm: draw a bunch of examples and output any consistent hypothesis. The question is, how many examples do we need to guarantee that the hypothesis we find has the prescribed generalization error? It will certainly grow with , but we need to ensure it will only grow polynomially fast in this parameter. Indeed, realizability is such a strong assumption that we can prove a polynomial bound using even more basic probability theory than the Chernoff bound.
Theorem: A algorithm that efficiently finds a consistent hypothesis will PAC-learn any finite concept class provided it has at least samples, where
Proof. All we need to do is bound the probability that a bad hypothesis (one with error more than ) is consistent with the given data. Now fix , and draw examples and let be any hypothesis that is consistent with the drawn examples. Suppose that the bad thing happens, that .
Because the examples are all drawn independently from , the chance that all examples are consistent with is
What we’re saying here is, the probability that a specific bad hypothesis is actually consistent with your drawn examples is exponentially small in the error tolerance. So if we apply the union bound, the probability that some hypothesis you could produce is bad is at most , where is the number of hypotheses the algorithm might produce.
A crude upper bound on the number of hypotheses you could produce is just the total number of hypotheses, . Even cruder, let’s use the inequality to give the bound
Now we want to make sure that this probability, the probability of choosing a high-error (yet consistent) hypothesis, is at most . So we can set the above quantity less than and solve for :
Taking logs and solving for gives the desired bound.
An obvious objection is: what if you aren’t working with a hypothesis class where you can guarantee that you’ll find a consistent hypothesis? Well, in that case we’ll need to inspect the definition of PAC again and reevaluate our measures of error. It turns out we’ll get a similar theorem as above, but with the stipulation that we’re only achieving error within epsilon of the error of the best available hypothesis.
But before we go on, this theorem has some deep philosophical interpretations. In particular, suppose that, before drawing your data, you could choose to work with one of two finite hypothesis classes , with . If you can find a consistent hypothesis no matter which hypothesis class you use, then this theorem says that your generalization guarantees are much stronger if you start with the smaller hypothesis class.
In other words, all else being equal, the smaller set of hypotheses is better. For this reason, the theorem is sometimes called the “Occam’s Razor” theorem. We’ll see a generalization of this theorem in the next section.
Unrealizability and an extra epsilon
Now suppose that $H$ doesn’t contain any hypotheses with error less than . What can we hope to do in this case? One thing is that we can hope to find a hypothesis whose error is within of the minimal error of any hypothesis in . Moreover, we might not have any consistent hypotheses for some data samples! So rather than require an algorithm to produce an that is perfectly consistent with the data, we just need it to produce a hypothesis that has minimal empirical error, in the sense that it is as close to consistent as the best hypothesis of on the data you happened to draw. It seems like such a strategy would find you a hypothesis that’s close to the best one in , but we need to prove it and determine how many samples we need to draw to succeed.
So let’s make some definitions to codify this. For a given hypothesis, call the true error of on the distribution . Our assumption is that there may be no hypotheses in with . Next we’ll call the empirical error .
Definition: We say a concept class is agnostically learnable using the hypothesis class if for all and all distributions (and all ), there is a learning algorithm which produces a hypothesis that with probability at least satisfies
and everything runs in the same sort of polynomial time as for vanilla PAC-learning. This is called the agnostic setting or the unrealizable setting, in the sense that we may not be able to find a hypothesis with perfect empirical error.
We seek to prove that all concept classes are agnostically learnable with a finite hypothesis class, provided you have an algorithm that can minimize empirical error. But actually we’ll prove something stronger.
Theorem: Let be a finite hypothesis class and the number of samples drawn. Then for any , with probability the following holds:
In other words, we can precisely quantify how the empirical error converges to the true error as the number of samples grows. But this holds for all hypotheses in , so this provides a uniform bound of the difference between true and empirical error for the entire hypothesis class.
Proving this requires the Chernoff bound. Fix a single hypothesis . If you draw an example , call the random variable which is 1 when , and 0 otherwise. So if you draw samples and call the -th variable , the empirical error of the hypothesis is . Moreover, the actual error is the expectation of this random variable since .
So what we’re asking is the probability that the empirical error deviates from the true error by a lot. Let’s call “a lot” some parameter (the reason for dividing by two will become clear in the corollary to the theorem). Then plugging things into the Chernoff-Hoeffding bound gives a bound on the probability of the “bad event,” that the empirical error deviates too much.
Now to get a bound on the probability that some hypothesis is bad, we apply the union bound and use the fact that is finite to get
Now say we want to bound this probability by . We set , solve for , and get
This gives us a concrete quantification of the tradeoff between and . Indeed, if we pick to be this large, then solving for gives the exact inequality from the theorem.
Now we know that if we pick enough samples (polynomially many in all the parameters), and our algorithm can find a hypothesis of minimal empirical error, then we get the following corollary:
Corollary: For any , the algorithm that draws examples and finds any hypothesis of minimal empirical error will, with probability at least , produce a hypothesis that is within of the best hypothesis in .
Proof. By the previous theorem, with the desired probability, for all we have . Call . Then because the empirical error of is also minimal, we have . And using the previous theorem again and the triangle inequality, we get . In words, the true error of the algorithm’s hypothesis is close to the error of the best hypothesis, as desired.
Both of these theorems tell us something about the generalization guarantees for learning with hypothesis classes of a certain size. But this isn’t exactly the most reasonable measure of the “complexity” of a family of hypotheses. For example, one could have a hypothesis class with a billion intervals on (say you’re trying to learn intervals, or thresholds, or something easy), and the guarantees we proved in this post are nowhere near optimal.
So the question is: say you have a potentially infinite class of hypotheses, but the hypotheses are all “simple” in some way. First, what is the right notion of simplicity? And second, how can you get guarantees based on that analogous to these? We’ll discuss this next time when we define the VC-dimension.
Problem: Two players take turns moving a rook on an 8×8 chessboard. The rook is only allowed to move south or west (but not both in a single turn), and may move any number of squares in the chosen direction on a turn. The loser is the player who first cannot move the rook. What is the optimal play for any starting position?
Solution: Take advantage of the symmetry of the board. If the rook is not on the diagonal, the optimal strategy is to move it to the diagonal. Then when the other player moves it off, your next move is to move it back to the diagonal. If your opponent starts their turn with the rook always on the diagonal, then you will never lose, and by the symmetry of the board you can always move the rook back to the diagonal. This provides an optimal algorithm for either player. In particular, if the rook starts on a square that is not on the diagonal, then player 1 can guarantee a win, and otherwise player 2 can.
Symmetry is one of the most powerful tools in all of mathematics, and this is a simple albeit illustrative example of its usage.