Last updated 18 May 2006.

How to use the DRF dataset with the CRF2D toolbox

This page describes how to load the datasets used in the following paper:

S. Kumar and M. Hebert. Discriminative Fields for Modeling Spatial Dependencies in Natural Images. Advances in Neural Information Processing Systems, NIPS 16, 2004.

This allows one to replicate the experiments performed in:

S. Vishwanathan, N. Schraudolph, M. Schmidt, K. Murphy. Accelerated Training of Conditional Random Fields with Stochastic Meta-Descent ICML'06 (Intl Conf on Machine Learning)

Note that our definition of local evidence features is slightly different from Kumar and Herbert (who use log(sigmoid(w^T x)). Also, their inference and learning procedures are different than ours. But the results are qualitatively similar.

Binary Denoising Data

1. Make a folder called 'DATA' in the same directory as CRF2D.
2. Download the binary denoising data from Sanjiv Kumar's webpage to the 'DATA' directory (direct link).
3. Unzip and Untar the downloaded file.
4. In Matlab, add the paths for both the data and the CRF2D code. In Matlab 7, from the directory containing both 'CRF2D' and 'DATA':
```
>> addpath(genpath(pwd))
```
5. Load the first binary denoising data set:
```
>> load dataMat_multSyn1N90
```
6. Permute the matrix to be in the format (feature,row,column,case):
```
>> data = permute(dataMat, [3 1 2 4]);
```
7. Load the corresponding labels:
```
>> load totalLabels_synIm1
```
8. Specify training and testing indices (there are a total of 50 images), for example:
```
>> trainNdx = 1:40; testNdx = 41:50
```

9. Make a corresponding feature engine and training/testing data:

featureEng = latticeFeatures(0,0); % Just use raw features and bias
traindata.nodeFeatures = mkNodeFeatures(featureEng, data(:,:,:,trainNdx));
traindata.edgeFeatures = mkEdgeFeatures(featureEng, data(:,:,:,trainNdx));
traindata.nodeLabels = totalLabels(:,:,trainNdx);
traindata.ncases = length(trainNdx);
testdata.nodeFeatures = mkNodeFeatures(featureEng, data(:,:,:,testNdx));
testdata.edgeFeatures = mkEdgeFeatures(featureEng, data(:,:,:,testNdx));
testdata.nodeLabels = totalLabels(:,:,testNdx);
testdata.ncases = length(testNdx);

10. The data is now in the appropriate format, so training and inference can be performed as in the usage page. The other data sets can be loaded by changing the load command(s) above to load the appropriate .mat file.

Man Made Structure Detection Data

Note: this section requires code for computing feature vectors from raw images. We use matlab/C code written by Tim Rees for his CS532C class project in Fall 2004; click here for his final report and here for his feature code. (Tim used pseudo likelihood for training.)

1. Make a folder called 'DATA' in the same directory as CRF2D.
2. Download the man-made structure detection data from Sanjiv Kumar's webpage to the 'DATA' directory (direct link).
3. Untar the downloaded file.

4. Make four directories in the 'DATA' folder:

mkdir('DATA/totalImagesTrain');
mkdir('DATA/totalImagesTest');
mkdir('DATA/totalLabelsTrain');
mkdir('DATA/totalLabelsTest');

5. Place each of the 4 tar archives into the corresponding folders.
6. Untar the archives in each of the 4 folders.
7. Download our man-made structure detection feature extraction code here.
8. Extract the contents of 'manMade.zip' to the directory containing 'CRF2D' and 'DATA' (this creates a directory called 'manMade'.
9. Add the paths for both the data and the CRF2D code. In Matlab 7, from the directory containing both 'CRF2D', 'DATA', and 'manMade':
```
>> addpath(genpath(pwd))
```

10. Run the feature extraction code:

>> genTrainingFeatures
>> genTestingFeatures

11. Load the raw training and testing data:

trainCell = load('trainingFeatures.mat');
testCell = load('testingFeatures.mat');

12. Specify training and testing indices (there are a total of 108 training images, and 129 testing images), for example:
```
trainNdx = 1:108
testNdx = 1:129
```

13. Make a feature engine (that uses a quadratic expansion of the node features), and the corresponding train/test in the appropriate format using the 'convertManMade' function:

expandNodes = 1; expandEdges = 0;
featureEng = latticeFeatures(expandNodes, expandEdges);
traindata = convertManMade(featureEng, trainCell.ssFea, trainCell.msFea, trainCell.corrLabels,  trainNdx);
testdata = convertManMade(featureEng, testCell.ssFea, testCell.msFea, testCell.corrLabels, testNdx);

14. The data is now in the appropriate format, so training and inference can be performed as in the usage page.

Reproducing the ICML06 Experiments

After the data has been placed in an appropriate location and features extracted for the man-made data, the experiments (and variants) from the ICML06 paper can be ran using some additional scripts downloadable here.

The main script in this archive is called 'run.m', it takes four arguments (see the paper for details):

dataName: either 'manMade' or 'denoise'

objective: either 'PL', 'MF', or 'LBP'

method: either 'BFGS', 'SGD', 'ASGD', or 'SMD'

outFile: the name of the .mat file that will store the paths of the training negative log-likelihood and test errors (Figures 4+6).

You should get results like the following on the digit denoising

The legend is here

You should get results like the following on the manmade building patch classification task