Greg's Notebook, Spring 2007

---

Back to Greg's Wiki

---

May 11 : Are The Trees Balanced?

Iterative cascade:
c1=makecascade([],3,10,25,200,1:256,1,10);
viewcascade(c1);

Spectra cascade:
c2=makecascade([],3,10,25,200,1:256,2,2);
viewcascade(c2);

Iterative grouping (left) seems to produce a more balanced cascade than spectral clustering(right).

But that doesn't necessarily mean that performance is better as a function of testint time.

Iterative grouping: viewgroups(conf,{c1{8}.cats c1{9}.cats c1{10}.cats c1{11}.cats c1{12}.cats c1{13}.cats c1{14}.cats c1{15}.cats})

Spectral grouping: viewgroups(conf,{c2{8}.cats c2{9}.cats c2{10}.cats c2{11}.cats c2{12}.cats c2{13}.cats c2{14}.cats c2{15})

May 9 : Cascade Training

c= makecascade([],3,10,25,200,1:256,2,2,(1:9)/10,100,2,6); 
viewcascade(c);

On subsequent calls you don't have to keep re-generating the leave-n-out confusion matrix, just reuse what you've already done:

c= makecascade(c,3,10,25,200,1:256,2,2,(1:9)/10,100,2,6);

Until you wipe it, we assume everything that is currently in the cascade is correct and does not need to be regenerated.

Apr 20 : ICCV Challenge Preparations

Routines to write (X means done) X imcats256: return all available categories X impick256: pick files for a given seed X imread256: read images as grayscale X imshow256: Display a group of images train256: find training kernel test256: find testing kernel conf256: construct confusion matrix perf256: compute performance Software documentation Train/test description

Run for case of simple correlation classifier Create mailing group for contest Then add more routines tree256: construct confusion matrix with respect to a specific tree tree1, tree2, tree3: three different trees Put canonical file lists (10trials x4 categories) on web Run for case of pyramid matching Merielle Generate 2nd hand-made tree Generate WordNet tree

Apr 15 : Cascade Software

This time I'll try using Lightspeed timing, and also the tree routines from the Robust Control Toolbox.

New cascade routines will be divided cleanly between training and testing:

MATLAB Routines
Training	Testing
cascade=cascadetrain(ntrain,ntest,nword,maxdepth) generates and trains a brand new cascade by creating a root node with nodeinit and applying nodetrain recursively. root=nodeinit(node) add (or reference) kernel, gtruth and images node=nodetrain(node) create cmatrix and group nodes()=nodesplit(node) use group above to split off 3 new nodes 1/2/null	cascadetest(cascade,depth,leakage) run each of the test images through the cascade and find out which node it terminates in, for a given leakage value. nodetest(node,leakage) generate the test fields below for a given leakage value
Data Structures
Training	Testing
train gtruth  : ground truth claases for every training image cmatrix : confusion matrix built using only training data (canonical indices), cluster this to create: group : group assignments (1,2) for each training image based on cmatrix time : number of seconds (cputime) spent in each phase	test gtruth : ground truth classes for each test image group : group assignments guess : class assignments for every test image, which are ultimate compared to gtruth. time : cputime (in sec) spent in each phase
ntrain, ntest, nword : where train/test kernels are located

Additional changes:

makesvm15 : uses probabilities instead of raw margin values. May or may not load match kernels from file each time. Combine ntrain,ntest,nword into a structure or not? Make or may not create svminit which stores all the svm parameters: it is becoming cumbersome to keep passing these things around.

Functional Difference

One (possibly significant) difference is that we're going to figure out which training images are support vectors, then only compute time to match those training images. How does the total number of training images to be matched per test image vary with threshold? This is the part I want to track carefully: just how many matches need to be computed.