dualsparsedoublefeaturestest.m

a function inside machine learning

%A function to test dualSparseDoubleFeatures 
clear all;
rand('state',21); 

numExamples = 150; 
numXFeatures = 10; 
numYFeatures = 20; 

X = rand(numExamples, numXFeatures); 
Y = rand(numExamples, numYFeatures); 

X = centerData(X); 
Y = centerData(Y); 

[trainX, trainY, testX, testY] = splitData(X, Y, 2/3); 

numTrainExamples = size(trainX, 1); 

tol = 10^-2; 
T = 10; 

params.dualSparseMeasureFunction = 'sparseCorrelations';
params.iterations = T;
params.X.kernel.name = 'linearKernel';
params.X.kernel.params = struct;
params.Y.kernel.name = 'linearKernel';
params.Y.kernel.params = struct;
params.chunkSize = 500;
params.numKernelCols = 500;
params.normalise = 1;

[newTrainX, newTrainY, newTestX, newTestY, subspaceInfo] = dualSparseDoubleFeatures(trainX, trainY, testX, testY, params);

%Now we'll try doing it manually 
KX = trainX*trainX'; 
KY = trainY*trainY'; 

bX = sparse(numTrainExamples, T); 
bY = sparse(numTrainExamples, T); 

tauX = zeros(numTrainExamples, T); 
tauY = zeros(numTrainExamples, T); 

KXj = KX; 
KYj = KY; 

for i=1:T 
    fprintf('Iteration %d \n', i); 
    [correlations, bXs, bYs] = sparseCorrelations(KX, KXj, KY, KYj, 1:numTrainExamples, 1:numTrainExamples);
    [m, n] = maxInMatrix(abs(correlations));

    bX(m, i) = bXs(m);
    bY(n, i) = bYs(n);
    
    tauX(:, i) = KXj*bX(:, i); 
    tauY(:, i) = KYj*bY(:, i); 
    
    KXj = KXj - ((tauX(:, i)*tauX(:, i)')/(tauX(:, i)'*tauX(:, i)))*KXj;
    KYj = KYj - ((tauY(:, i)*tauY(:, i)')/(tauY(:, i)'*tauY(:, i)))*KYj;
end

if norm(full(bX) - full(subspaceInfo.XInfo.b)) > tol
    bX
    subspaceInfo.bX
    error('Dual X projection vectors are incorrect'); 
end 

if norm(full(bY) - full(subspaceInfo.YInfo.b)) > tol
    error('Dual Y projection vectors are incorrect'); 
end 

if norm(newTrainX - tauX) > tol
    error('New X features are incorrect'); 
end 

if norm(newTrainY - tauY) > tol
    error('New Y features are incorrect'); 
end 

if trace(newTrainX'*newTrainX) - sum(sum(newTrainX'*newTrainX)) > tol
    error('Training X data is not orthogonal'); 
end 

if trace(newTrainY'*newTrainY) - sum(sum(newTrainY'*newTrainY)) > tol
    error('Training Y data is not orthogonal'); 
end 

%Test out sparse data 
trainX = sparse(trainX); 
trainY = sparse(trainY); 
KX = trainX*trainX'; 
KY = trainY*trainY'; 

trainData = data; 
trainData = addDataField(trainData, 'X', trainX, 'examples'); 
trainData = addDataField(trainData, 'Y', trainY, 'labels');

[subspaceInfo, trainInfo] = dualSparseDoubleFeaturesTrain(trainData, params);

newTrainX = getDataFieldValue(trainInfo.data, 'X'); 
newTrainY = getDataFieldValue(trainInfo.data, 'Y'); 


%Now try using data that is larger than the chunk size 
trainX = full(trainX); 
trainY = full(trainY); 

trainData = data; 
trainData = addDataField(trainData, 'X', trainX, 'examples'); 
trainData = addDataField(trainData, 'Y', trainY, 'labels');

params.numKernelCols = floor(numTrainExamples/2);
[subspaceInfo, trainInfo] = dualSparseDoubleFeaturesTrain(trainData, params);

newTrainX = getDataFieldValue(trainInfo.data, 'X'); 
newTrainY = getDataFieldValue(trainInfo.data, 'Y'); 

if trace(newTrainX'*newTrainX) - sum(sum(newTrainX'*newTrainX)) > tol
    error('Training X data is not orthogonal'); 
end 

if trace(newTrainY'*newTrainY) - sum(sum(newTrainY'*newTrainY)) > tol
    error('Training Y data is not orthogonal'); 
end 

%Try it without normalisation and test the projection function 
params.normalise = 1;
trainData = data; 
trainData = addDataField(trainData, 'X', trainX, 'examples'); 
trainData = addDataField(trainData, 'Y', trainY, 'labels'); 

testData = data; 
testData = addDataField(testData, 'X', testX, 'examples'); 
testData = addDataField(testData, 'Y', testY, 'labels'); 

[subspaceInfo, trainInfo] = dualSparseDoubleFeaturesTrain(trainData, params);
[testInfo, projectionInfo] = dualSparseDoubleFeaturesProject(trainData, trainData, subspaceInfo, params);

newTrainX = getDataFieldValue(trainInfo.data, 'X'); 
newTrainY = getDataFieldValue(trainInfo.data, 'Y'); 
newTestX = getDataFieldValue(testInfo.data, 'X'); 
newTestY = getDataFieldValue(testInfo.data, 'Y'); 

if norm(newTrainX - newTestX)  > tol 
    dbstack; 
    error('X projections are wrong'); 
end 

if norm(newTrainY - newTestY) > tol 
    error('Y projections are wrong'); 
end 

%Now compare results to dualSparseDoubleFeatures
params.numKernelCols = 500;
trainData = data; 
trainData = addDataField(trainData, 'X', trainX, 'examples'); 
trainData = addDataField(trainData, 'Y', trainY, 'labels'); 

testData = data; 
testData = addDataField(testData, 'X', testX, 'examples'); 
testData = addDataField(testData, 'Y', testY, 'labels'); 
[subspaceInfo, trainInfo] = dualSparseDoubleFeaturesTrain(trainData, params);
[testInfo, projectionInfo] = dualSparseDoubleFeaturesProject(trainData, testData, subspaceInfo, params);

[newTrainX2, newTrainY2, newTestX2, newTestY2, subspaceInfo] = dualSparseDoubleFeatures(trainX, trainY, testX, testY, params);

newTrainX = getDataFieldValue(trainInfo.data, 'X'); 
newTrainY = getDataFieldValue(trainInfo.data, 'Y'); 
newTestX = getDataFieldValue(testInfo.data, 'X'); 
newTestY = getDataFieldValue(testInfo.data, 'Y'); 

if (norm(newTrainX2 - newTrainX)  > tol)  | (norm(newTrainY2 - newTrainY)  > tol)
    error('Training projections are wrong'); 
end 

if (norm(newTestX2 - newTestX)  > tol)  | (norm(newTestY2 - newTestY)  > tol)
    error('Training projections are wrong'); 
end