1 / 66

660 likes | 801 Vues

Some Other Efficient Learning Methods. William W. Cohen. Announcements. Upcoming guest lectures: Alona Fyshe , 2/9 & 2/14 Ron Bekkerman (LinkedIn), 2/23 Joey Gonzalez, 3/8 U Kang, 3/22 Phrases assignment out today: Unsupervised learning Google n-grams data Non-trivial pipeline

Télécharger la présentation
## Some Other Efficient Learning Methods

**An Image/Link below is provided (as is) to download presentation**
Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.
Content is provided to you AS IS for your information and personal use only.
Download presentation by click this link.
While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.
During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

**Some Other Efficient Learning Methods**William W. Cohen**Announcements**• Upcoming guest lectures: • AlonaFyshe, 2/9 & 2/14 • Ron Bekkerman (LinkedIn), 2/23 • Joey Gonzalez, 3/8 • U Kang, 3/22 • Phrases assignment out today: • Unsupervised learning • Google n-grams data • Non-trivial pipeline • Make sure you allocate time to actually run the program • Hadoop assignment (out 2/14): • We’re giving you two assignments, both due 2/28 • More time to master Amazon cloud and Hadoop mechanics • You really should have the first one done after 1 week**Review/outline**• Streaming learning algorithms • Naïve Bayes • Rocchio’s algorithm • Similarities & differences • Probabilistic vs vector space models • Computationally: • linear classifiers (inner product x and v(y)) • constant number of passes over data • very simple with word counts in memory • pretty simple for large vocabularies • trivially parallelized adding operations • Alternative: • Adding up contributions for every example vs conservatively updating a linear classifier • On-line learning model: mistake-bounds**Review/outline**• Streaming learning algorithms … and beyond • Naïve Bayes • Rocchio’s algorithm • Similarities & differences • Probabilistic vs vector space models • Computationally similar • Parallelizing Naïve Bayes and Rocchio • Alternative: • Adding up contributions for every example vs conservatively updating a linear classifier • On-line learning model: mistake-bounds • some theory • a mistake bound for perceptron • Parallelizing the perceptron**Parallel Rocchio**“extra” work in parallel version Documents/labels Split into documents subsets Documents/labels – 1 Documents/labels – 2 Documents/labels – 3 Compute DFs DFs -1 DFs - 2 DFs -3 Sort and add counts DFs**Parallel Rocchio**extra work in parallel version Documents/labels DFs Split into documents subsets Documents/labels – 1 Documents/labels – 2 Documents/labels – 3 Compute partial v(y)’s v-1 v-3 v-2 Sort and add vectors v(y)’s**Limitations of Naïve Bayes/Rocchio**This isn’t silly – often there are features that are “noisy” duplicates, or important phrases of different length • Naïve Bayes: one pass • Rocchio: two passes • if vocabulary fits in memory • Both method are algorithmically similar • count and combine • Thought thought thought thought thought thought thought thought thought thought experiment: what if we duplicated some features in our dataset many times times times times times times times times times times? • e.g., Repeat all words that start with “t” “t” “t” “t” “t” “t” “t” “t” “t” “t” ten ten ten ten ten ten ten ten ten ten timestimestimestimestimestimestimestimestimes times. • Result: those features will be over-weighted in classifier by a factor of 10**Limitations of Naïve Bayes/Rocchio**This isn’t silly – often there are features that are “noisy” duplicates, or important phrases of different length • Naïve Bayes: one pass • Rocchio: two passes • if vocabulary fits in memory • Both method are algorithmically similar • count and combine • Result: with duplication some features will be over-weighted in classifier • unless you can somehow notice are correct for interactions/dependencies between features • Claim: naïve Bayes is fast becauseit’s naive**Naïve Bayes is fast because it’s naïve**• Key ideas: • Pick the class variable Y • Instead of estimating P(X1,…,Xn,Y) = P(X1)*…*P(Xn)*Pr(Y), estimate P(X1,…,Xn|Y) = P(X1|Y)*…*P(Xn|Y) • Or, assume P(Xi|Y)=Pr(Xi|X1,…,Xi-1,Xi+1,…Xn,Y) • Or, that Xi is conditionally independent of every Xj, j!=I, given Y. • How to estimate? MLE**One simple way to look for interactions**Naïve Bayes sparse vector of TF values for each word in the document…plus a “bias” term for f(y) dense vector of g(x,y) scores for each word in the vocabulary .. plus f(y) to match bias term**One simple way to look for interactions**• Scan thru data: • whenever we see x with y we increase g(x,y)-g(x,~y) • whenever we see x with ~y we decrease g(x,y)-g(x,~y) Naïve Bayes – two class version • To detect interactions: • increase/decrease g(x,y)-g(x,~y) only if we need to (for that example) • otherwise, leave it unchanged dense vector of g(x,y) scores for each word in the vocabulary**^**If mistake: vk+1 = vk + correction Compute: yi = vk . xi A “Conservative” Streaming Algorithm is Sensitive to Duplicated Features Train Data instancexi B +1,-1: label yi • To detect interactions: • increase/decrease vk only if we need to (for that example) • otherwise, leave it unchanged (“conservative”) • We can be sensitive to duplication by coupling updates to feature weights with classifier performance (and hence with other updates)**Parallel Rocchio**Documents/labels DFs Split into documents subsets Documents/labels – 1 Documents/labels – 2 Documents/labels – 3 Compute partial v(y)’s v-1 v-3 v-2 Sort and add vectors v(y)’s**Parallel Conservative Learning**Like DFs or event counts, size is O(|V|) Documents/labels Classifier Split into documents subsets Documents/labels – 1 Documents/labels – 2 Documents/labels – 3 Compute partial v(y)’s v-1 v-3 v-2 v(y)’s Key Point: We need shared write access to the classifier – not just read access. So we only need to not copy the information but synchronize it. Question: How much extra communication is there?**Parallel Conservative Learning**Like DFs or event counts, size is O(|V|) Documents/labels Classifier Split into documents subsets Documents/labels – 1 Documents/labels – 2 Documents/labels – 3 Compute partial v(y)’s v-1 v-3 v-2 Key Point: We need shared write access to the classifier – not just read access. So we only need to not copy the information but synchronize it. Question: How much extra communication is there? Answer: Depends on how the learner behaves… …how many weights get updated with each example … (in Naïve Bayes and Rocchio, only weights for features with non-zero weight in x are updated when scanning x) …how often it needs to update weight … (how many mistakes it makes) v(y)’s**Review/outline**• Streaming learning algorithms … and beyond • Naïve Bayes • Rocchio’s algorithm • Similarities & differences • Probabilistic vs vector space models • Computationally similar • Parallelizing Naïve Bayes and Rocchio • easier than parallelizing a conservative algorithm? • Alternative: • Adding up contributions for every example vs conservatively updating a linear classifier • On-line learning model: mistake-bounds • some theory • a mistake bound for perceptron • Parallelizing the perceptron**^**If mistake: vk+1 = vk + correction Compute: yi = vk . xi A “Conservative” Streaming Algorithm Train Data instancexi B +1,-1: label yi**Theory: the prediction game**• Player A: • picks a “target concept” c • for now - from a finite set of possibilities C (e.g., all decision trees of size m) • for t=1,…., • Player A picks x=(x1,…,xn) and sends it to B • For now, from a finite set of possibilities (e.g., all binary vectors of length n) • B predicts a label, ŷ, and sends it to A • A sends B the true label y=c(x) • we record if B made a mistake or not • We care about the worst case number of mistakes B will make over all possible concept & training sequences of any length • The “Mistake bound” for B, MB(C), is this bound**Some possible algorithms for B**not practical – just possible • The “optimal algorithm” • Build a min-max game tree for the prediction game and use perfect play C 00 01 10 11 ŷ(01)=0 ŷ(01)=1 y=0 y=1 {c in C:c(01)=1} {c in C: c(01)=0}**Some possible algorithms for B**not practical – just possible • The “optimal algorithm” • Build a min-max game tree for the prediction game and use perfect play Suppose B only makes a mistake on each x a finite number of times k (say k=1). After each mistake, the set of possible concepts will decrease…so the tree will have bounded size. C 00 01 10 11 ŷ(01)=0 ŷ(01)=1 y=0 y=1 {c in C:c(01)=1} {c in C: c(01)=0}**Some possible algorithms for B**not practical – just possible • The “Halving algorithm” • Remember all the previous examples • To predict, cycle through all cin the “version space” of consistent concepts in c,and record which predict 1 and which predict 0 • Predict according to the majority vote • Analysis: • With every mistake, the size of the version space is decreased in size by at least half • So Mhalving(C) <= log2(|C|)**Some possible algorithms for B**not practical – just possible • The “Halving algorithm” • Remember all the previous examples • To predict, cycle through all cin the “version space” of consistent concepts in c,and record which predict 1 and which predict 0 • Predict according to the majority vote • Analysis: • With every mistake, the size of the version space is decreased in size by at least half • So Mhalving(C) <= log2(|C|) C 00 01 10 11 ŷ(01)=0 ŷ(01)=1 y=0 y=1 y=1 {c in C:c(01)=1} {c in C: c(01)=0}**More results**• A set s is “shattered” by C if for any subset s’ of s, there is a c in C that contains all the instances in s’ and none of the instances ins-s’. • The “VC dimension” of C is |s|, where sis the largest set shattered by C. • VCdim is closely related to pac-learnability of concepts in C.**More results**• A set s is “shattered” by C if for any subset s’ of s, there is a c in C that contains all the instances in s’ and none of the instances ins-s’. • The “VC dimension” of C is |s|, where sis the largest set shattered by C.**More results**• A set s is “shattered” by C if for any subset s’ of s, there is a c in C that contains all the instances in s’ and none of the instances ins-s’. • The “VC dimension” of C is |s|, where sis the largest set shattered by C. C • Theorem: • Mopt(C)>=VC(C) • Proof: game tree has depth >= VC(C) 00 01 10 11 ŷ(01)=0 ŷ(01)=1 y=0 y=1 {c in C:c(01)=1} {c in C: c(01)=0}**More results**• A set s is “shattered” by C if for any subset s’ of s, there is a c in C that contains all the instances in s’ and none of the instances ins-s’. • The “VC dimension” of C is |s|, where sis the largest set shattered by C. C • Corollary: for finite C • VC(C) <= Mopt(C) <= log2(|C|) 00 01 10 11 ŷ(01)=0 ŷ(01)=1 • Proof: Mopt(C) <= Mhalving(C) • <=log2(|C|) y=0 y=1 {c in C:c(01)=1} {c in C: c(01)=0}**More results**• A set s is “shattered” by C if for any subset s’ of s, there is a c in C that contains all the instances in s’ and none of the instances ins-s’. • The “VC dimension” of C is |s|, where sis the largest set shattered by C. • Theorem: it can be that • Mopt(C) >> VC(C) • Proof: C = set of one-dimensional threshold functions. - ? +**The prediction game**• Are there practical algorithms where we can compute the mistake bound?**^**^ Compute: yi = sign(vk. xi) yi yi The perceptron game x is a vector y is -1 or +1 instancexi B A If mistake: vk+1 = vk + yixi**u**u v1 +x1 -u -u 2γ 2γ v2 (1) A target u (2) The guess v1 after one positive example. (3a) The guess v2 after the two positive examples: v2=v1+x2 (3b) The guess v2 after the one positive and one negative example: v2=v1-x2 u u +x2 v2 v1 v1 +x1 -x2 -u -u 2γ 2γ If mistake: vk+1 = vk + yixi**v2**(3a) The guess v2 after the two positive examples: v2=v1+x2 (3b) The guess v2 after the one positive and one negative example: v2=v1-x2 u u +x2 v2 >γ v1 v1 +x1 -x2 -u -u 2γ 2γ If mistake: vk+1 = vk + yixi**v2**(3a) The guess v2 after the two positive examples: v2=v1+x2 (3b) The guess v2 after the one positive and one negative example: v2=v1-x2 u u +x2 v2 v1 v1 +x1 -x2 -u -u 2γ 2γ If mistake: yixi vk< 0**2**2 2 2 2 Notation fix to be consistent with next paper**Summary**• We have shown that • If : exists a uwith unit norm that has margin γ on examples in the seq (x1,y1),(x2,y2),…. • Then : the perceptron algorithm makes < R2/ γ2 mistakes on the sequence (where R >= ||xi||) • Independent of dimension of the data or classifier (!) • This doesn’t follow from M(C)<=VCDim(C) • We don’t know if this algorithm could be better • There are many variants that rely on similar analysis (ROMMA, Passive-Aggressive, MIRA, …) • We don’tknow what happens if the data’s not separable • Unless I explain the “Δtrick” to you • We don’t know what classifier to use “after” training**On-line to batch learning**• Pick a vk at random according to mk/m, the fraction of examples it was used for. • Predict using the vk you just picked. • (Actually, use some sort of deterministic approximation to this).**Complexity of perceptron learning**• Algorithm: • v=0 • for each example x,y: • if sign(v.x) != y • v= v+ yx • init hashtable • for xi!=0, vi += yxi O(n) O(|x|)=O(|d|)**Complexity of averaged perceptron**• Algorithm: • vk=0 • va = 0 • for each example x,y: • if sign(vk.x) != y • va = va + nkvk • vk= vk+ yx • nk = 1 • else • nk++ • init hashtables • for vki!=0, vai += vki • for xi!=0, vi += yxi O(n) O(n|V|) O(|V|) O(|x|)=O(|d|) So: averaged perceptron is better from point of view of accuracy (stability, …) but much more expensive computationally.**Complexity of averaged perceptron**• Algorithm: • vk=0 • va = 0 • for each example x,y: • if sign(vk.x) != y • va = va + nkvk • vk= vk+ yx • nk = 1 • else • nk++ • init hashtables • for vki!=0, vai += vki • for xi!=0, vi += yxi O(n) O(n|V|) O(|V|) O(|x|)=O(|d|) The non-averaged perceptron is also hard to parallelize…**A hidden agenda**• Part of machine learning is good grasp of theory • Part of ML is a good grasp of what hacks tend to work • These are not always the same • Especially in big-data situations • Catalog of useful tricks so far • Brute-force estimation of a joint distribution • Naive Bayes • Stream-and-sort, request-and-answer patterns • BLRT and KL-divergence (and when to use them) • TF-IDF weighting – especially IDF • it’s often useful even when we don’t understand why • Perceptron • often leads to fast, competitive, easy-to-implement methods • averaging helps • what about parallel perceptrons?**Parallel Conservative Learning**vk/va Documents/labels Classifier Split into documents subsets Documents/labels – 1 Documents/labels – 2 Documents/labels – 3 Compute partial v(y)’s v-1 v-3 v-2 v(y)’s**Parallelizing perceptrons**Instances/labels Split into example subsets Instances/labels – 1 Instances/labels – 2 Instances/labels – 3 Compute vk’s on subsets vk/va -1 vk/va- 2 vk/va-3 Combine somehow? vk**Aside: this paper is on structuredperceptrons**• …but everything they say formally applies to the standard perceptron as well • Briefly: a structured perceptron uses a weight vector to rank possible structured predictions y’ using features f(x,y’) • Instead ofincrementing weight vector by yx, the weight vector is incremented by f(x,y)-f(x,y’)**Parallel Perceptrons**• Simplest idea: • Split data into S “shards” • Train a perceptron on each shard independently • weight vectors are w(1) , w(2) , … • Produce some weighted average of the w(i)‘s as the final result**Parallelizing perceptrons**Instances/labels Split into example subsets Instances/labels – 1 Instances/labels – 2 Instances/labels – 3 Compute vk’s on subsets vk -1 vk- 2 vk-3 Combine by some sort of weighted averaging vk**Parallel Perceptrons**• Simplest idea: • Split data into S “shards” • Train a perceptron on each shard independently • weight vectors are w(1) , w(2) , … • Produce some weighted average of the w(i)‘s as the final result • Theorem: this doesn’t always work. • Proof: by constructing an example where you can converge on every shard, and still have the averaged vector not separate the full training set – no matter how you average the components.**Parallel Perceptrons – take 2**• Idea: do the simplest possible thing iteratively. • Split the data into shards • Let w = 0 • For n=1,… • Train a perceptron on each shard with one passstarting with w • Average the weight vectors (somehow) and let wbe that average • Extra communication cost: • redistributing the weight vectors • done less frequently than if fully synchronized, more frequently than if fully parallelized

More Related