Difference between revisions of "Daume ICML 2009"

From Cohen Courses
Jump to navigationJump to search
Line 19: Line 19:
 
In the supervised form, the algorithm uses a sample space of <math>(x,y)</math> pairs, where <math>x</math> is the input and <math>y</math> is the true output. In the unsupervised case, we must account for the fact that the algorithm must be run on an input of simply <math>x</math>, with the classifier still producing <math>y</math>.
 
In the supervised form, the algorithm uses a sample space of <math>(x,y)</math> pairs, where <math>x</math> is the input and <math>y</math> is the true output. In the unsupervised case, we must account for the fact that the algorithm must be run on an input of simply <math>x</math>, with the classifier still producing <math>y</math>.
  
The proposed solution is to essentially predict <math>y</math>, and then perform the normal prediction. The loss function will only be dependent on <math>x</math>.
+
The proposed solution is to essentially predict <math>y</math>, and then perform the normal prediction. The loss function will only be dependent on <math>x</math>, as, while we will be predicting <math>y</math>, we do not have any observed "true" outputs.
  
Given an input <math>x</math>, which is a sequence of length <math>T</math>, we consider the true output to be of length <math>2T</math>, where the first <math>T</math> components will be sampled from the possible vocabulary for <math>y</math>, and represent the latent structure, and the last <math>T</math> components are the true input <math>x</math>. We can then use [[UsesMethod::SEARN|SEARN]] on this input.  
+
Given an input <math>x</math>, which is a sequence of length <math>T</math>, we consider the true output to be of length <math>2T</math>, where the first <math>T</math> components will be drawn from the possible vocabulary for <math>y</math> (that is, the possible outputs), and represent the latent structure (which we will refer to as <math>y<math>, and the last <math>T</math> components are the drawn from the vocabulary for the input, <math>x</math>. We can then use [[UsesMethod::SEARN|SEARN]] on this input. It is important to note that constructing features for these two parts is different:
  
In dealing with <math>\pi*</math>, the optimal (and thus initial) policy, it already predicts fully the true input, and it can arbitrarily/randomly predict the latent input. This gives us the ability to run the first iteration of [[UsesMethod::SEARN|SEARN]]
+
* For <math>y</math>, the <math>T</math> latent components, they can be based on <math>x</math> and the partial latent structure (i.e., at <math>y_t</math>, we can look at <math>y_1,...,y_{t-1}</math>)
 +
* For <math>x</math>, the <math>T</math> input components, they can be based on <math>x</math> and <math>y</math>. However, the paper notes that in designing features here, the ideal feature set will be dependent on correctly predicting the latent structure correctly. This makes intuitive sense - if we correctly predict <math>y</math>, then we have an "optimal" label set.
 +
 
 +
In dealing with <math>\pi*</math>, the optimal (and thus initial) policy, it already predicts fully the true input, and it can arbitrarily/randomly predict the latent input. This gives us the ability to run the first iteration of [[UsesMethod::SEARN|SEARN]].
 +
 
 +
The paper describes the unsupervised algorithm as follows:
 +
 
 +
* First iteration: Use <math>\pi = \pi*</math> to classify the sequence of latent and input components. Note that <math>\pi*</math> randomly or arbitrarily produces classifications for the latent components, and all of the costs are 0, so this won't even induce any update to the classifier for these components. The important piece is that <math>\pi*</math> ''does'' predict classifications for the input components, and recall that these predictions will produce input symbols, taken from the true input.
 +
* Second iteration: Given that <math>\pi \neq \pi*</math> due to the update, we no longer are guaranteed to produce zero-cost classifications for the latent component. Given that features for the latent structure are based partially on <math>x</math>, they get either high costs if the classifier performs poorly, or low costs if it performs well. As a result, the classifier will begin to predict classifications for the latent component.
 +
* More iterations will cause the output to be closer to the learned classifier and further from the "optimal" policy (which arbitrarily produced the classifications).

Revision as of 23:16, 29 September 2011

In progress by Francis Keith

Citation

"Unsupervised Search-based Structured Prediction", Hal Daume III, ICML 2009

Online Version

An online version of the paper can be found here [1]

Summary

This paper details a methodology for unsupervised SEARN. It compares the results to other methods, first on synthetic data, and then on other methods for unsupervised dependency parsing.

Algorithm

The basic SEARN algorithm is described (see the SEARN wiki article for more background).

In the supervised form, the algorithm uses a sample space of pairs, where is the input and is the true output. In the unsupervised case, we must account for the fact that the algorithm must be run on an input of simply , with the classifier still producing .

The proposed solution is to essentially predict , and then perform the normal prediction. The loss function will only be dependent on , as, while we will be predicting , we do not have any observed "true" outputs.

Given an input , which is a sequence of length , we consider the true output to be of length , where the first components will be drawn from the possible vocabulary for (that is, the possible outputs), and represent the latent structure (which we will refer to as components are the drawn from the vocabulary for the input, . We can then use SEARN on this input. It is important to note that constructing features for these two parts is different:

  • For , the latent components, they can be based on and the partial latent structure (i.e., at , we can look at )
  • For , the input components, they can be based on and . However, the paper notes that in designing features here, the ideal feature set will be dependent on correctly predicting the latent structure correctly. This makes intuitive sense - if we correctly predict , then we have an "optimal" label set.

In dealing with , the optimal (and thus initial) policy, it already predicts fully the true input, and it can arbitrarily/randomly predict the latent input. This gives us the ability to run the first iteration of SEARN.

The paper describes the unsupervised algorithm as follows:

  • First iteration: Use to classify the sequence of latent and input components. Note that randomly or arbitrarily produces classifications for the latent components, and all of the costs are 0, so this won't even induce any update to the classifier for these components. The important piece is that does predict classifications for the input components, and recall that these predictions will produce input symbols, taken from the true input.
  • Second iteration: Given that due to the update, we no longer are guaranteed to produce zero-cost classifications for the latent component. Given that features for the latent structure are based partially on , they get either high costs if the classifier performs poorly, or low costs if it performs well. As a result, the classifier will begin to predict classifications for the latent component.
  • More iterations will cause the output to be closer to the learned classifier and further from the "optimal" policy (which arbitrarily produced the classifications).