def stl_demo():
"""Performs a demo classification on stl
"""
logging.info('Loading stl data...')
stl = visiondata.STL10Dataset(FLAGS.root, 'unlabeled', target_size=32)
stl_train = visiondata.STL10Dataset(FLAGS.root, 'train', target_size=32)
stl_test = visiondata.STL10Dataset(FLAGS.root, 'test', target_size=32)
conv = pipeline.ConvLayer([
pipeline.PatchExtractor([6, 6], 1), # extracts patches
pipeline.MeanvarNormalizer({'reg': 10}), # normalizes the patches
pipeline.LinearEncoder({},
trainer = pipeline.ZcaTrainer({'reg': 0.1})),
pipeline.ThresholdEncoder({'alpha': 0.25, 'twoside': False},
trainer = pipeline.NormalizedKmeansTrainer(
{'k': FLAGS.fromdim, 'max_iter':100})),
pipeline.SpatialPooler({'grid': (FLAGS.grid, FLAGS.grid), 'method': FLAGS.method}) # average pool
])
logging.info('Training the pipeline...')
conv.train(stl, 400000, exhaustive = True)
logging.info('Extracting features...')
X = conv.process_dataset(stl, as_2d = False)
Xtrain = conv.process_dataset(stl_train, as_2d = False)
Ytrain = stl_train.labels().astype(np.int)
Xtest = conv.process_dataset(stl_test, as_2d = False)
Ytest = stl_test.labels().astype(np.int)
# before we do feature computation, try to do dimensionality reduction
X.resize(np.prod(X.shape[:-1]), X.shape[-1])
Xtrain.resize(np.prod(Xtrain.shape[:-1]), Xtrain.shape[-1])
Xtest.resize(np.prod(Xtest.shape[:-1]), Xtest.shape[-1])
m, std = classifier.feature_meanstd(X, 0.01)
X -= m
X /= std
Xtrain -= m
Xtrain /= std
Xtest -= m
Xtest /= std
covmat = mathutil.mpi_cov(X)
current_dim = FLAGS.fromdim
if FLAGS.svd == 1:
eigval, eigvec = np.linalg.eigh(covmat)
while current_dim >= 100:
if current_dim < FLAGS.fromdim:
if FLAGS.svd == 1:
# directly do dimensionality reduction
U = eigvec[:, -current_dim:]
Xtrain_red = np.dot(Xtrain, U)
Xtest_red = np.dot(Xtest, U)
else:
# do subsampling
temp = code_ap.code_af(X, current_dim, tol=current_dim * 0.01)
logging.info("selected %d dims" % len(temp[0]))
sel = temp[0]
sel = mpi.COMM.bcast(sel)
Cpred = covmat[sel]
Csel = Cpred[:,sel]
W = np.linalg.solve(Csel, Cpred)
# perform svd
U, D, _ = np.linalg.svd(W, full_matrices = 0)
U *= D
Xtrain_red = np.dot(Xtrain[:, sel], U)
Xtest_red = np.dot(Xtest[:, sel], U)
Xtrain_red.resize(Ytrain.shape[0], Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
else:
Xtrain_red = Xtrain.copy()
Xtest_red = Xtest.copy()
Xtrain_red.resize(Ytrain.shape[0], Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
w, b = classifier.l2svm_onevsall(Xtrain_red, Ytrain, 0.005,
fminargs={'disp': 0, 'maxfun': 1000})
accu_train = classifier.Evaluator.accuracy(Ytrain, np.dot(Xtrain_red, w) + b)
accu_test = classifier.Evaluator.accuracy(Ytest, np.dot(Xtest_red, w) + b)
logging.info('%d - %d, Training accuracy: %f' % (FLAGS.fromdim, current_dim, accu_train))
logging.info('%d - %d, Testing accuracy: %f' % (FLAGS.fromdim, current_dim, accu_test))
current_dim /= 2
covmat = mathutil.mpi_cov(Xtrain)
current_dim = FLAGS.todim
if FLAGS.svd == 1:
eigval, eigvec = np.linalg.eigh(covmat)
# hack to run only one dim
while current_dim >= FLAGS.todim:
if current_dim < FLAGS.fromdim:
if FLAGS.svd == 1:
# directly do dimensionality reduction
U = eigvec[:, -current_dim:]
Xtrain_red = np.dot(Xtrain, U)
Xtest_red = np.dot(Xtest, U)
else:
# do subsampling
temp = code_ap.code_af(Xtrain, current_dim)
logging.info("selected %d dims" % len(temp[0]))
sel = temp[0]
sel = mpi.COMM.bcast(sel)
Cpred = covmat[sel]
Csel = Cpred[:, sel]
W = np.linalg.solve(Csel, Cpred)
# perform svd
U, D, _ = np.linalg.svd(W, full_matrices=0)
U *= D
Xtrain_red = np.dot(Xtrain[:, sel], U)
Xtest_red = np.dot(Xtest[:, sel], U)
Xtrain_red.resize(Ytrain.shape[0], Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
else:
Xtrain_red = Xtrain.copy()
def cifar_demo():
"""Performs a demo classification on cifar
"""
mpi.mkdir(FLAGS.output_dir)
logging.info('Loading cifar data...')
cifar = visiondata.CifarDataset(FLAGS.root, is_training=True)
cifar_test = visiondata.CifarDataset(FLAGS.root, is_training=False)
conv = pipeline.ConvLayer([
pipeline.PatchExtractor([6, 6], 1), # extracts patches
pipeline.MeanvarNormalizer({'reg': 10}), # normalizes the patches
pipeline.LinearEncoder({},
trainer = pipeline.ZcaTrainer({'reg': 0.1})),
pipeline.ThresholdEncoder({'alpha': 0.25, 'twoside': False},
trainer = pipeline.NormalizedKmeansTrainer(
{'k': FLAGS.fromdim, 'max_iter':100})),
pipeline.SpatialPooler({'grid': (FLAGS.grid, FLAGS.grid), 'method': FLAGS.method}) # average pool
])
logging.info('Training the pipeline...')
conv.train(cifar, 400000, exhaustive = True)
logging.info('Extracting features...')
Xtrain = conv.process_dataset(cifar, as_2d = False)
Ytrain = cifar.labels().astype(np.int)
Xtest = conv.process_dataset(cifar_test, as_2d = False)
Ytest = cifar_test.labels().astype(np.int)
# before we do feature computation, try to do dimensionality reduction
Xtrain.resize(np.prod(Xtrain.shape[:-1]), Xtrain.shape[-1])
Xtest.resize(np.prod(Xtest.shape[:-1]), Xtest.shape[-1])
m, std = classifier.feature_meanstd(Xtrain, 0.01)
Xtrain -= m
Xtrain /= std
Xtest -= m
Xtest /= std
covmat = mathutil.mpi_cov(Xtrain)
current_dim = FLAGS.fromdim
if FLAGS.svd == 1:
eigval, eigvec = np.linalg.eigh(covmat)
while current_dim >= 100:
if current_dim < FLAGS.fromdim:
if FLAGS.svd == 1:
# directly do dimensionality reduction
U = eigvec[:, -current_dim:]
Xtrain_red = np.dot(Xtrain, U)
Xtest_red = np.dot(Xtest, U)
else:
# do subsampling
temp = code_ap.code_af(Xtrain, current_dim)
logging.info("selected %d dims" % len(temp[0]))
sel = temp[0]
Xtrain_red = np.ascontiguousarray(Xtrain[:, sel])
Xtest_red = np.ascontiguousarray(Xtest[:, sel])
Xtrain_red.resize(Ytrain.shape[0], Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
else:
Xtrain_red = Xtrain.copy()
Xtest_red = Xtest.copy()
Xtrain_red.resize(Ytrain.shape[0], Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
w, b = classifier.l2svm_onevsall(Xtrain_red, Ytrain, 0.005,
fminargs={'disp': 0, 'maxfun': 1000})
accu_train = classifier.Evaluator.accuracy(Ytrain, np.dot(Xtrain_red, w) + b)
accu_test = classifier.Evaluator.accuracy(Ytest, np.dot(Xtest_red, w) + b)
logging.info('%d - %d, Training accuracy: %f' % (FLAGS.fromdim, current_dim, accu_train))
logging.info('%d - %d, Testing accuracy: %f' % (FLAGS.fromdim, current_dim, accu_test))
current_dim /= 2
def stl_demo():
"""Performs a demo classification on stl
"""
logging.info('Loading stl data...')
stl = visiondata.STL10Dataset(FLAGS.root, 'unlabeled', target_size=32)
stl_train = visiondata.STL10Dataset(FLAGS.root, 'train', target_size=32)
stl_test = visiondata.STL10Dataset(FLAGS.root, 'test', target_size=32)
conv = pipeline.ConvLayer([
pipeline.PatchExtractor([6, 6], 1), # extracts patches
pipeline.MeanvarNormalizer({'reg': 10}), # normalizes the patches
pipeline.LinearEncoder({}, trainer=pipeline.ZcaTrainer({'reg': 0.1})),
pipeline.ThresholdEncoder({
'alpha': 0.25,
'twoside': False
},
trainer=pipeline.NormalizedKmeansTrainer({
'k':
FLAGS.fromdim,
'max_iter':
100
})),
pipeline.SpatialPooler({
'grid': (FLAGS.grid, FLAGS.grid),
'method': FLAGS.method
}) # average pool
])
logging.info('Training the pipeline...')
conv.train(stl, 400000, exhaustive=True)
logging.info('Extracting features...')
X = conv.process_dataset(stl, as_2d=False)
Xtrain = conv.process_dataset(stl_train, as_2d=False)
Ytrain = stl_train.labels().astype(np.int)
Xtest = conv.process_dataset(stl_test, as_2d=False)
Ytest = stl_test.labels().astype(np.int)
# before we do feature computation, try to do dimensionality reduction
X.resize(np.prod(X.shape[:-1]), X.shape[-1])
Xtrain.resize(np.prod(Xtrain.shape[:-1]), Xtrain.shape[-1])
Xtest.resize(np.prod(Xtest.shape[:-1]), Xtest.shape[-1])
m, std = classifier.feature_meanstd(X, 0.01)
X -= m
X /= std
Xtrain -= m
Xtrain /= std
Xtest -= m
Xtest /= std
covmat = mathutil.mpi_cov(X)
current_dim = FLAGS.fromdim
if FLAGS.svd == 1:
eigval, eigvec = np.linalg.eigh(covmat)
while current_dim >= 100:
if current_dim < FLAGS.fromdim:
if FLAGS.svd == 1:
# directly do dimensionality reduction
U = eigvec[:, -current_dim:]
Xtrain_red = np.dot(Xtrain, U)
Xtest_red = np.dot(Xtest, U)
else:
# do subsampling
temp = code_ap.code_af(X, current_dim, tol=current_dim * 0.01)
logging.info("selected %d dims" % len(temp[0]))
sel = temp[0]
sel = mpi.COMM.bcast(sel)
Cpred = covmat[sel]
Csel = Cpred[:, sel]
W = np.linalg.solve(Csel, Cpred)
# perform svd
U, D, _ = np.linalg.svd(W, full_matrices=0)
U *= D
Xtrain_red = np.dot(Xtrain[:, sel], U)
Xtest_red = np.dot(Xtest[:, sel], U)
Xtrain_red.resize(Ytrain.shape[0],
Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
else:
Xtrain_red = Xtrain.copy()
Xtest_red = Xtest.copy()
Xtrain_red.resize(Ytrain.shape[0],
Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
w, b = classifier.l2svm_onevsall(Xtrain_red,
Ytrain,
0.005,
fminargs={
'disp': 0,
'maxfun': 1000
})
accu_train = classifier.Evaluator.accuracy(Ytrain,
np.dot(Xtrain_red, w) + b)
accu_test = classifier.Evaluator.accuracy(Ytest,
np.dot(Xtest_red, w) + b)
logging.info('%d - %d, Training accuracy: %f' %
(FLAGS.fromdim, current_dim, accu_train))
logging.info('%d - %d, Testing accuracy: %f' %
(FLAGS.fromdim, current_dim, accu_test))
current_dim /= 2
def cifar_demo():
"""Performs a demo classification on cifar
"""
mpi.mkdir(FLAGS.output_dir)
logging.info('Loading cifar data...')
cifar = visiondata.CifarDataset(FLAGS.root, is_training=True)
cifar_test = visiondata.CifarDataset(FLAGS.root, is_training=False)
conv = pipeline.ConvLayer([
pipeline.PatchExtractor([6, 6], 1), # extracts patches
pipeline.MeanvarNormalizer({'reg': 10}), # normalizes the patches
pipeline.LinearEncoder({}, trainer=pipeline.ZcaTrainer({'reg': 0.1})),
pipeline.ThresholdEncoder({
'alpha': 0.25,
'twoside': False
},
trainer=pipeline.NormalizedKmeansTrainer({
'k':
FLAGS.fromdim,
'max_iter':
100
})),
pipeline.SpatialPooler({
'grid': (FLAGS.grid, FLAGS.grid),
'method': FLAGS.method
}) # average pool
])
logging.info('Training the pipeline...')
conv.train(cifar, 400000, exhaustive=True)
logging.info('Extracting features...')
Xtrain = conv.process_dataset(cifar, as_2d=False)
Ytrain = cifar.labels().astype(np.int)
Xtest = conv.process_dataset(cifar_test, as_2d=False)
Ytest = cifar_test.labels().astype(np.int)
# before we do feature computation, try to do dimensionality reduction
Xtrain.resize(np.prod(Xtrain.shape[:-1]), Xtrain.shape[-1])
Xtest.resize(np.prod(Xtest.shape[:-1]), Xtest.shape[-1])
m, std = classifier.feature_meanstd(Xtrain, 0.01)
Xtrain -= m
Xtrain /= std
Xtest -= m
Xtest /= std
covmat = mathutil.mpi_cov(Xtrain)
current_dim = FLAGS.fromdim
if FLAGS.svd == 1:
eigval, eigvec = np.linalg.eigh(covmat)
while current_dim >= 100:
if current_dim < FLAGS.fromdim:
if FLAGS.svd == 1:
# directly do dimensionality reduction
U = eigvec[:, -current_dim:]
Xtrain_red = np.dot(Xtrain, U)
Xtest_red = np.dot(Xtest, U)
else:
# do subsampling
temp = code_ap.code_af(Xtrain, current_dim)
logging.info("selected %d dims" % len(temp[0]))
sel = temp[0]
Xtrain_red = np.ascontiguousarray(Xtrain[:, sel])
Xtest_red = np.ascontiguousarray(Xtest[:, sel])
Xtrain_red.resize(Ytrain.shape[0],
Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
else:
Xtrain_red = Xtrain.copy()
Xtest_red = Xtest.copy()
Xtrain_red.resize(Ytrain.shape[0],
Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
w, b = classifier.l2svm_onevsall(Xtrain_red,
Ytrain,
0.005,
fminargs={
'disp': 0,
'maxfun': 1000
})
accu_train = classifier.Evaluator.accuracy(Ytrain,
np.dot(Xtrain_red, w) + b)
accu_test = classifier.Evaluator.accuracy(Ytest,
np.dot(Xtest_red, w) + b)
logging.info('%d - %d, Training accuracy: %f' %
(FLAGS.fromdim, current_dim, accu_train))
logging.info('%d - %d, Testing accuracy: %f' %
(FLAGS.fromdim, current_dim, accu_test))
current_dim /= 2
covmat = mathutil.mpi_cov(Xtrain)
current_dim = FLAGS.todim
if FLAGS.svd == 1:
eigval, eigvec = np.linalg.eigh(covmat)
# hack to run only one dim
while current_dim >= FLAGS.todim:
if current_dim < FLAGS.fromdim:
if FLAGS.svd == 1:
# directly do dimensionality reduction
U = eigvec[:, -current_dim:]
Xtrain_red = np.dot(Xtrain, U)
Xtest_red = np.dot(Xtest, U)
else:
# do subsampling
temp = code_ap.code_af(Xtrain, current_dim)
logging.info("selected %d dims" % len(temp[0]))
sel = temp[0]
sel = mpi.COMM.bcast(sel)
Cpred = covmat[sel]
Csel = Cpred[:,sel]
W = np.linalg.solve(Csel, Cpred)
# perform svd
U, D, _ = np.linalg.svd(W, full_matrices = 0)
U *= D
Xtrain_red = np.dot(Xtrain[:, sel], U)
Xtest_red = np.dot(Xtest[:, sel], U)
Xtrain_red.resize(Ytrain.shape[0], Xtrain_red.size / Ytrain.shape[0])
Xtest_red.resize(Ytest.shape[0], Xtest_red.size / Ytest.shape[0])
else:
Xtrain_red = Xtrain.copy()
