def test_DropoutPerLayer(self):
nn = MLPR(layers=[L("Rectifier", units=8, dropout=0.25), L("Linear")],
regularize='dropout',
n_iter=1)
assert_equal(nn.regularize, 'dropout')
self._run(nn)
assert_in('Using `dropout` for regularization.', self.output.getvalue())
def run_EqualityTest(self, copier, asserter):
for activation in ["Rectifier", "Sigmoid", "Maxout", "Tanh"]:
nn1 = MLPR(layers=[L(activation, units=16, pieces=2), L("Linear", units=1)], random_state=1234)
nn1._initialize(self.a_in, self.a_out)
nn2 = copier(nn1, activation)
asserter(numpy.all(nn1.predict(self.a_in) == nn2.predict(self.a_in)))
def test_RegularizeExplicitL1(self):
nn = MLPR(layers=[L("Tanh", units=8), L("Linear",)],
regularize='L1',
n_iter=1)
assert_equal(nn.regularize, 'L1')
self._run(nn)
assert_in('Using `L1` for regularization.', self.output.getvalue())
def test_RegularizeCustomParam(self):
nn = MLPR(layers=[L("Tanh", units=8), L("Linear",)],
weight_decay=0.01,
n_iter=1)
assert_equal(nn.weight_decay, 0.01)
self._run(nn)
assert_in('Using `L2` for regularization.', self.output.getvalue())
def test_DropoutPerLayer(self):
nn = MLPR(layers=[L("Maxout", units=8, pieces=2, dropout=0.25), L("Linear")],
regularize='dropout',
n_iter=1)
assert_equal(nn.regularize, 'dropout')
self._run(nn)
assert_true(nn.cost is not None)
def test_DropoutExplicit(self):
nn = MLPR(layers=[L("Tanh", units=8), L("Linear",)],
regularize='dropout',
n_iter=1)
assert_equal(nn.regularize, 'dropout')
self._run(nn)
assert_in('Using `dropout` for regularization.', self.output.getvalue())
def test_DropoutExplicit(self):
nn = MLPR(layers=[L("Tanh", units=8), L("Linear",)],
regularize='dropout',
n_iter=1)
assert_equal(nn.regularize, 'dropout')
self._run(nn)
assert_true(nn.cost is not None)
def test_RegularizeCustomParam(self):
nn = MLPR(layers=[L("Tanh", units=8), L("Linear",)],
weight_decay=0.01,
n_iter=1)
assert_equal(nn.weight_decay, 0.01)
self._run(nn)
assert_true(nn.cost is not None)
def test_RegularizeExplicitL2(self):
nn = MLPR(layers=[L("Sigmoid", units=8), L("Softmax",)],
regularize='L2',
n_iter=1)
assert_equal(nn.regularize, 'L2')
self._run(nn)
assert_in('Using `L2` for regularization.', self.output.getvalue())
def test_DropoutAsFloat(self):
nn = MLPR(layers=[L("Tanh", units=8), L("Linear",)],
dropout_rate=0.25,
n_iter=1)
assert_equal(nn.regularize, 'dropout')
assert_equal(nn.dropout_rate, 0.25)
self._run(nn)
assert_true(nn.cost is not None)
def test_GaussianNoise(self):
nn = MLPR(layers=[
L("Rectifier", units=12),
N(ly.GaussianNoiseLayer),
L("Linear")
],
n_iter=1)
self._run(nn)
def test_DropoutAsFloat(self):
nn = MLPR(layers=[L("Tanh", units=8), L("Linear",)],
dropout_rate=0.25,
n_iter=1)
assert_equal(nn.regularize, 'dropout')
assert_equal(nn.dropout_rate, 0.25)
self._run(nn)
assert_in('Using `dropout` for regularization.', self.output.getvalue())
def test_RandomLayerParams(self):
clf = RandomizedSearchCV(
self.__estimator__(layers=[L("Softmax", units=12),
L("Linear")],
n_iter=1),
param_distributions={'hidden0__units': randint(4, 12)},
n_iter=2)
clf.fit(self.a_in, self.a_out)
def test_AutomaticRegularize(self):
nn = MLPR(
layers=[L("Tanh", units=8, weight_decay=0.0001),
L("Linear")],
n_iter=1)
self._run(nn)
assert_in('Using `L2` for regularization, auto-enabled from layers.',
self.output.getvalue())
def ctor(_, activation):
nn = MLPR(layers=[
L(activation, units=16, pieces=2),
L("Linear", units=1)
],
random_state=1234)
nn._initialize(self.a_in, self.a_out)
return nn
def setUp(self):
self.nn = MLPR(layers=[
L("Rectifier", units=16),
L("Sigmoid", dropout=0.2, units=12),
L("ExpLin", weight_decay=0.001, units=8),
L("Tanh", normalize='batch', units=4),
L("Linear")
],
n_iter=1)
def setUp(self):
self.nn = MLPR(
layers=[
L("Rectifier", units=16),
L("Sigmoid", units=12),
L("ExpLin", units=8),
L("Tanh", units=4),
L("Linear")],
n_iter=1)
def test_RegressorLayerParams(self):
a_in = numpy.random.uniform(0.0, 1.0, (64, 16))
a_out = numpy.zeros((64, 1))
clf = GridSearchCV(MLPR(layers=[L("Rectifier", units=12),
L("Linear")],
n_iter=1),
param_grid={'hidden0__units': [4, 8, 12]})
clf.fit(a_in, a_out)
def test_RegularizePerLayer(self):
nn = MLPR(layers=[
L("Rectifier", units=8, weight_decay=0.01),
L("Linear", weight_decay=0.001)
],
n_iter=1)
self._run(nn)
assert_in('Using `L2` for regularization, auto-enabled from layers.',
self.output.getvalue())
def test_RandomMultipleJobs(self):
clf = RandomizedSearchCV(
self.__estimator__(
layers=[L("Sigmoid", units=12),
L(self.__output__)], n_iter=1),
param_distributions={'hidden0__units': randint(4, 12)},
n_iter=4,
n_jobs=4)
clf.fit(self.a_in, self.a_out)
def setUp(self):
self.nn = MLPR(layers=[
L("Rectifier", units=16),
L("Sigmoid", units=12),
L("Maxout", units=16, pieces=2),
L("Tanh", units=4),
L("Linear")
],
n_iter=1)
def make(self, activation, seed=1234, train=False, **keywords):
nn = MLPR(
layers=[L(activation, units=16, **keywords),
L("Linear", units=1)],
random_state=seed,
n_iter=1)
if train:
nn.fit(self.a_in, self.a_out)
else:
nn._initialize(self.a_in, self.a_out)
return nn
def test_BatchNormPerLayer(self):
nn = MLPR(layers=[
C("Sigmoid", normalize='batch', channels=2, kernel_shape=(3, 3)),
L("Rectifier", normalize='batch', units=8),
L("Linear", )
],
n_iter=1)
self._run(nn)
assert_in('Using `batch` normalization, auto-enabled from layers.',
self.output.getvalue())
assert_in('Reshaping input array', self.buf.getvalue())
self.buf = io.StringIO()
def test_TrainConstantOneEpoch(self):
for t in ['csr_matrix', 'csc_matrix']:
sparse_matrix = getattr(scipy.sparse, t)
X_s, y_s = sparse_matrix((8, 16), dtype=numpy.float32), sparse_matrix((8, 16), dtype=numpy.float32)
X, y = X_s.toarray(), y_s.toarray()
nn1 = MLP(layers=[L("Linear")], n_iter=1, random_state=1234)
nn1._fit(X, y)
nn2 = MLP(layers=[L("Linear")], n_iter=1, random_state=1234)
nn2._fit(X_s, y_s)
assert_true(numpy.all(nn1._predict(X_s) == nn1._predict(X_s)))
def run_EqualityTest(self, copier, asserter):
# Only PyLearn2 supports Maxout.
extra = ["Maxout"] if sknn.backend.name == 'pylearn2' else []
for activation in ["Rectifier", "Sigmoid", "Tanh", "ExpLin"] + extra:
nn1 = MLPR(layers=[L(activation, units=16), L("Linear", units=1)], random_state=1234)
nn1._initialize(self.a_in, self.a_out)
nn2 = copier(nn1, activation)
print('activation', activation)
a_out1 = nn1.predict(self.a_in)
a_out2 = nn2.predict(self.a_in)
print(a_out1, a_out2)
asserter(numpy.all(nn1.predict(self.a_in) - nn2.predict(self.a_in) < 1E-6))
def test_SetLayerParamsDict(self):
nn = MLPR(layers=[L("Sigmoid", units=32), L("Linear", name='abcd')])
a_in, a_out = numpy.zeros((8, 16)), numpy.zeros((8, 4))
nn._initialize(a_in, a_out)
weights = numpy.random.uniform(-1.0, +1.0, (32, 4))
biases = numpy.random.uniform(-1.0, +1.0, (4, ))
nn.set_parameters({'abcd': (weights, biases)})
p = nn.get_parameters()
assert_true((
p[1].weights.astype('float32') == weights.astype('float32')).all())
assert_true(
(p[1].biases.astype('float32') == biases.astype('float32')).all())
def test_BatchNormExplicit(self):
nn = MLPR(layers=[
C("Tanh", channels=2, kernel_shape=(3, 3)),
L("Sigmoid", units=8),
L("Linear", )
],
normalize='batch',
n_iter=1)
assert_equal(nn.normalize, 'batch')
self._run(nn)
assert_in('Using `batch` normalization.', self.output.getvalue())
assert_in('Reshaping input array', self.buf.getvalue())
self.buf = io.StringIO()
def test_HorizontalKernel(self):
self._run(
MLPR(layers=[
C("Rectifier", channels=4, kernel_shape=(1, 16)),
L("Linear")
],
n_iter=1))
def test_VerboseClassifier(self):
nn = MLPC(layers=[L("Softmax")], verbose=1, n_iter=1)
a_in, a_out = numpy.zeros((8,16)), numpy.zeros((8,1), dtype=numpy.int32)
nn.fit(a_in, a_out)
assert_in("Epoch Training Error Validation Error Time", self.buf.getvalue())
assert_in(" 1 ", self.buf.getvalue())
assert_in(" N/A ", self.buf.getvalue())
def test_VerboseRegressor(self):
nn = MLPR(layers=[L("Linear")], verbose=1, n_iter=1)
a_in, a_out = numpy.zeros((8,16)), numpy.zeros((8,4))
nn.fit(a_in, a_out)
assert_in("Epoch Training Error Validation Error Time", self.buf.getvalue())
assert_in(" 1 ", self.buf.getvalue())
assert_in(" N/A ", self.buf.getvalue())
