def test_zca(self):
"""
Confirm that ZCA.inv_P_ is the correct inverse of ZCA.P_.
There's a lot else about the ZCA class that could be tested here.
"""
preprocessor = ZCA()
preprocessor.fit(self.X)
identity = np.identity(self.X.shape[1], theano.config.floatX)
# Check some basics of transformation matrix
assert preprocessor.P_.shape == (self.X.shape[1], self.X.shape[1])
assert_allclose(np.dot(preprocessor.P_,
preprocessor.inv_P_), identity, rtol=1e-4)
preprocessor = ZCA(filter_bias=0.0)
preprocessed_X = self.get_preprocessed_data(preprocessor)
# Check if preprocessed data matrix is white
assert_allclose(np.cov(preprocessed_X.transpose(),
bias=1), identity, rtol=1e-4)
# Check if we obtain correct solution
zca_transformed_X = np.array(
[[-1.0199, -0.1832, 1.9528, -0.9603, -0.8162],
[0.0729, 1.4142, 0.2529, 1.1861, -1.0876],
[0.9575, -1.1173, -0.5435, -1.4372, -0.1057],
[0.6348, 1.1258, 0.2692, -0.8893, 1.1669],
[-0.9769, 0.8297, -1.8676, -0.6055, -0.5096],
[-1.5700, -0.8389, -0.0931, 0.8877, 1.6089],
[0.4993, -1.4219, -0.3443, 0.9664, -1.1022],
[1.4022, 0.1917, 0.3736, 0.8520, 0.8456]]
)
assert_allclose(preprocessed_X, zca_transformed_X, rtol=1e-3)
def test(store_inverse):
preprocessed_X = copy.copy(self.X)
preprocessor = ZCA(store_inverse=store_inverse)
dataset = DenseDesignMatrix(X=preprocessed_X,
preprocessor=preprocessor,
fit_preprocessor=True)
preprocessed_X = dataset.get_design_matrix()
assert_allclose(self.X, preprocessor.inverse(preprocessed_X))
def test_zca_dataset():
"""
Tests the ZCA_Dataset class.
"""
# Preparation
rng = np.random.RandomState([2014, 11, 4])
start = 0
stop = 990
num_examples = 1000
num_feat = 5
num_classes = 2
# random_dense_design_matrix has values that are centered and of
# unit stdev, which is not useful to test the ZCA.
# So, we replace its value by an uncentered uniform one.
raw = random_dense_design_matrix(rng, num_examples, num_feat, num_classes)
x = rng.uniform(low=-0.5, high=2.0, size=(num_examples, num_feat))
x = x.astype(np.float32)
raw.X = x
zca = ZCA(filter_bias=0.0)
zca.apply(raw, can_fit=True)
zca_dataset = ZCA_Dataset(raw, zca, start, stop)
# Testing general behaviour
mean = zca_dataset.X.mean(axis=0)
var = zca_dataset.X.std(axis=0)
assert_allclose(mean, np.zeros(num_feat), atol=1e-2)
assert_allclose(var, np.ones(num_feat), atol=1e-2)
# Testing mapback()
y = zca_dataset.mapback(zca_dataset.X)
assert_allclose(x[start:stop], y)
# Testing mapback_for_viewer()
y = zca_dataset.mapback_for_viewer(zca_dataset.X)
z = x/np.abs(x).max(axis=0)
assert_allclose(z[start:stop], y, rtol=1e-2)
# Testing adjust_for_viewer()
y = zca_dataset.adjust_for_viewer(x.T).T
z = x/np.abs(x).max(axis=0)
assert_allclose(z, y)
# Testing adjust_to_be_viewed_with()
y = zca_dataset.adjust_to_be_viewed_with(x, 2*x, True)
z = zca_dataset.adjust_for_viewer(x)
assert_allclose(z/2, y)
y = zca_dataset.adjust_to_be_viewed_with(x, 2*x, False)
z = x/np.abs(x).max()
assert_allclose(z/2, y)
# Testing has_targets()
assert zca_dataset.has_targets()
def test(store_inverse):
rng = np.random.RandomState([1, 2, 3])
X = as_floatX(rng.randn(15, 10))
preprocessed_X = copy.copy(X)
preprocessor = ZCA(store_inverse=store_inverse)
dataset = DenseDesignMatrix(X=preprocessed_X,
preprocessor=preprocessor,
fit_preprocessor=True)
preprocessed_X = dataset.get_design_matrix()
assert_allclose(X, preprocessor.inverse(preprocessed_X))
def test(store_inverse):
rng = np.random.RandomState([1, 2, 3])
X = as_floatX(rng.randn(15, 10))
preprocessed_X = copy.copy(X)
preprocessor = ZCA(store_inverse=store_inverse)
dataset = DenseDesignMatrix(X=preprocessed_X,
preprocessor=preprocessor,
fit_preprocessor=True)
preprocessed_X = dataset.get_design_matrix()
assert_allclose(X, preprocessor.inverse(preprocessed_X))
def test_zca_dataset():
"""
Test that a ZCA dataset can be constructed without crashing. No
attempt to verify correctness of behavior.
"""
rng = np.random.RandomState([2014, 11, 4])
num_examples = 5
dim = 3
num_classes = 2
raw = random_dense_design_matrix(rng, num_examples, dim, num_classes)
zca = ZCA()
zca.apply(raw, can_fit=True)
zca_dataset = ZCA_Dataset(raw, zca, start=1, stop=4)
def test_zca_dtypes(self):
"""
Confirm that ZCA.fit works regardless of dtype of
data and config.floatX
"""
orig_floatX = config.floatX
try:
for floatX in ['float32', 'float64']:
for dtype in ['float32', 'float64']:
preprocessor = ZCA()
preprocessor.fit(self.X)
finally:
config.floatX = orig_floatX
def test_zca_dtypes(self):
"""
Confirm that ZCA.fit works regardless of dtype of
data and config.floatX
"""
orig_floatX = config.floatX
try:
for floatX in ['float32', 'float64']:
for dtype in ['float32', 'float64']:
preprocessor = ZCA()
preprocessor.fit(self.X)
finally:
config.floatX = orig_floatX
def test_zca_dtypes():
"""
Confirm that ZCA.fit works regardless of dtype of data and config.floatX
"""
orig_floatX = config.floatX
try:
for floatX in ['float32', 'float64']:
for dtype in ['float32', 'float64']:
rng = np.random.RandomState([1, 2, 3])
X = rng.randn(15, 10).astype(dtype)
preprocessor = ZCA()
preprocessor.fit(X)
finally:
config.floatX = orig_floatX
def test_zca_dtypes():
"""
Confirm that ZCA.fit works regardless of dtype of data and config.floatX
"""
orig_floatX = config.floatX
try:
for floatX in ['float32', 'float64']:
for dtype in ['float32', 'float64']:
rng = np.random.RandomState([1, 2, 3])
X = rng.randn(15, 10).astype(dtype)
preprocessor = ZCA()
preprocessor.fit(X)
finally:
config.floatX = orig_floatX
def test_zca():
"""
Confirm that ZCA.inv_P_ is the correct inverse of ZCA.P_.
There's a lot else about the ZCA class that could be tested here.
"""
rng = np.random.RandomState([1, 2, 3])
X = as_floatX(rng.randn(15, 10))
preprocessor = ZCA()
preprocessor.fit(X)
def is_identity(matrix):
identity = np.identity(matrix.shape[0], theano.config.floatX)
abs_difference = np.abs(identity - matrix)
return (abs_difference < .0001).all()
assert preprocessor.P_.shape == (X.shape[1], X.shape[1])
assert not is_identity(preprocessor.P_)
assert is_identity(np.dot(preprocessor.P_, preprocessor.inv_P_))
def test_zca():
"""
Confirm that ZCA.inv_P_ is the correct inverse of ZCA.P_.
There's a lot else about the ZCA class that could be tested here.
"""
rng = np.random.RandomState([1, 2, 3])
X = as_floatX(rng.randn(15, 10))
preprocessor = ZCA()
preprocessor.fit(X)
def is_identity(matrix):
identity = np.identity(matrix.shape[0], theano.config.floatX)
abs_difference = np.abs(identity - matrix)
return (abs_difference < .0001).all()
assert preprocessor.P_.shape == (X.shape[1], X.shape[1])
assert not is_identity(preprocessor.P_)
assert is_identity(np.dot(preprocessor.P_, preprocessor.inv_P_))
def test_num_components(self):
# Keep 3 components
preprocessor = ZCA(filter_bias=0.0, n_components=3)
preprocessed_X = self.get_preprocessed_data(preprocessor)
zca_truncated_X = np.array(
[[-0.8938, -0.3084, 1.1105, 0.1587, -1.4073],
[0.3346, 0.5193, 1.1371, 0.6545, -0.4199],
[0.7613, -0.4823, -1.0578, -1.1997, -0.4993],
[0.9250, 0.5012, -0.2743, 0.1735, 0.8105],
[-0.4928, -0.6319, -1.0359, -0.7173, 0.1469],
[-1.8060, -0.1758, -0.2943, 0.7208, 1.4359],
[0.0079, -0.2582, 0.1368, -0.3571, -0.8147],
[1.1636, 0.8362, 0.2777, 0.5666, 0.7480]])
assert_allclose(zca_truncated_X, preprocessed_X, rtol=1e-3)
# Drop 2 components: result should be similar
preprocessor = ZCA(filter_bias=0.0, n_drop_components=2)
preprocessed_X = self.get_preprocessed_data(preprocessor)
assert_allclose(zca_truncated_X, preprocessed_X, rtol=1e-3)
def test_zca(self):
"""
Confirm that ZCA.inv_P_ is the correct inverse of ZCA.P_.
There's a lot else about the ZCA class that could be tested here.
"""
preprocessor = ZCA()
preprocessor.fit(self.X)
identity = np.identity(self.X.shape[1], theano.config.floatX)
# Check some basics of transformation matrix
assert preprocessor.P_.shape == (self.X.shape[1], self.X.shape[1])
assert_allclose(np.dot(preprocessor.P_, preprocessor.inv_P_),
identity,
rtol=1e-4)
preprocessor = ZCA(filter_bias=0.0)
preprocessed_X = self.get_preprocessed_data(preprocessor)
# Check if preprocessed data matrix is white
assert_allclose(np.cov(preprocessed_X.transpose(), bias=1),
identity,
rtol=1e-4,
atol=1e-4)
# Check if we obtain correct solution
zca_transformed_X = np.array(
[[-1.0199, -0.1832, 1.9528, -0.9603, -0.8162],
[0.0729, 1.4142, 0.2529, 1.1861, -1.0876],
[0.9575, -1.1173, -0.5435, -1.4372, -0.1057],
[0.6348, 1.1258, 0.2692, -0.8893, 1.1669],
[-0.9769, 0.8297, -1.8676, -0.6055, -0.5096],
[-1.5700, -0.8389, -0.0931, 0.8877, 1.6089],
[0.4993, -1.4219, -0.3443, 0.9664, -1.1022],
[1.4022, 0.1917, 0.3736, 0.8520, 0.8456]])
assert_allclose(preprocessed_X, zca_transformed_X, rtol=1e-3)
from pylearn2.datasets.preprocessing import ZCA
from pylearn2.utils import serial
from black_box_dataset import BlackBoxDataset
extra = BlackBoxDataset('extra')
zca = ZCA(filter_bias=.1)
zca.fit(extra.X)
serial.save('zca.pkl', zca)
from pylearn2.datasets.mnist import MNIST
train = MNIST(which_set = 'train')
from pylearn2.datasets.preprocessing import ZCA
zca = ZCA()
zca.apply(train, can_fit=True)
from pylearn2.utils import serial
serial.save('mnist_zca.pkl', zca)
layers = [l1, l2, l3, l4, output]
mdl = mlp.MLP(layers,
input_space=in_space)
trainer = sgd.SGD(learning_rate=.17,
batch_size=128,
learning_rule=learning_rule.Momentum(.5),
# Remember, default dropout is .5
cost=Dropout(input_include_probs={'l1': .8},
input_scales={'l1': 1.}),
termination_criterion=EpochCounter(max_epochs=475),
monitoring_dataset={'valid': tst,
'train': trn})
preprocessor = Pipeline([GlobalContrastNormalization(scale=55.), ZCA()])
trn.apply_preprocessor(preprocessor=preprocessor, can_fit=True)
tst.apply_preprocessor(preprocessor=preprocessor, can_fit=False)
serial.save('kaggle_cifar10_preprocessor.pkl', preprocessor)
watcher = best_params.MonitorBasedSaveBest(
channel_name='valid_y_misclass',
save_path='kaggle_cifar10_maxout_zca.pkl')
velocity = learning_rule.MomentumAdjustor(final_momentum=.65,
start=1,
saturate=250)
decay = sgd.LinearDecayOverEpoch(start=1,
saturate=500,
decay_factor=.01)
from galatea.datasets.norb_tiny import NORB_Tiny
train = NORB_Tiny('train')
from pylearn2.datasets.preprocessing import Pipeline, GlobalContrastNormalization, ZCA
pipeline = Pipeline()
pipeline.items = [GlobalContrastNormalization(), ZCA()]
train.apply_preprocessor(pipeline, can_fit=True)
from pylearn2.utils.serial import save
save('norb_tiny_preprocessed_train.pkl', train)
save('norb_tiny_preprocessor.pkl', pipeline)
if __name__ == "__main__":
#Load dataset
train_x, test_x, train_y, test_y = unpack_facedataset(
) # 7:3 ratio for train:test
# preprocess images
# GCN and ZCA object!!
# Normalize and then ZCA whitening
# Normalized data only used on inversion, not in training
try:
zca = load("faces/zca.data")
except Exception as e:
print("Failed to load preprocessed data from disk, computing zca")
train_x_normalized = global_contrast_normalize(train_x * 255,
scale=55.)
zca = ZCA()
zca.fit(train_x_normalized)
save("faces/zca.data", zca)
x = tf.compat.v1.placeholder(tf.float32, shape=[None, 112 * 92])
y_ = tf.compat.v1.placeholder(tf.float32, shape=[None, 40])
model = Model(x, y_)
session = tf.compat.v1.InteractiveSession()
session.run(tf.compat.v1.global_variables_initializer())
#print(f"test {test_y.shape} t: {type(test_y)} ; train {train_y.shape} t: {type(train_y)}")
model.train(train_x, train_y, session, test_x, test_y, 250)
perform_inversion(zca, test_x[0::3], model, session)
# perform_inversion(train_x, test_x[0::3], model, session)
parser = argparse.ArgumentParser()
parser.add_argument('--folder')
parser.add_argument('-o')
args = parser.parse_args()
model_path = '/data/lisa/exp/wuzhen/conv2d/' + args.folder + '/convolutional_network_best.pkl'
import os
#X = np.load(os.environ['PYLEARN2_DATA_PATH'] + '/faceEmo/test_X.npy')
#y = np.load(os.environ['PYLEARN2_DATA_PATH'] + '/faceEmo/test_y.npy')
#print 'X.shape before', X.shape
X = np.load('test_input.npy')
X = X.astype('float32')
test_set = DenseDesignMatrix(X)
preproc = ZCA()
preproc.fit(test_set.X)
preproc.apply(test_set)
X = test_set.X
X = X.reshape(X.shape[0], 48, 48, 1).astype('float32')
f = open(model_path, 'rb')
mlp = cPickle.load(f)
X_theano = mlp.get_input_space().make_batch_theano()
#X_theano = T.tensor4()
y_theano = mlp.fprop(X_theano)
func = function(inputs=[X_theano], outputs=y_theano)
from pylearn2.datasets.mnist import MNIST
train = MNIST(which_set='train')
from pylearn2.datasets.preprocessing import ZCA
zca = ZCA()
zca.apply(train, can_fit=True)
from pylearn2.utils import serial
serial.save('mnist_zca.pkl', zca)
