def test_SquareKernel(self): self._run( MLPR(layers=[ C("Rectifier", channels=4, kernel_shape=(3, 3)), L("Linear") ], n_iter=1))
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 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_VerticalKernel(self): self._run( MLPR(layers=[ C("Rectifier", channels=4, kernel_shape=(16, 1)), L("Linear") ], n_iter=1))
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_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_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_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_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_LeakyRectifier(self): nn = MLPR(layers=[ N(ly.DenseLayer, units=24, nonlinearity=nl.leaky_rectify), L("Linear") ], n_iter=1) self._run(nn)
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_UnusedParameterWarning(self): nn = MLPR(layers=[L("Linear", pieces=2)], n_iter=1) a_in = numpy.zeros((8, 16)) nn._initialize(a_in, a_in) assert_in('Parameter `pieces` is unused', self.buf.getvalue()) self.buf = io.StringIO() # clear
def test_RegressorGlobalParams(self): a_in = numpy.random.uniform(0.0, 1.0, (64, 16)) a_out = numpy.zeros((64, 1)) clf = GridSearchCV(MLPR(layers=[L("Linear")], n_iter=1), param_grid={'learning_rate': [0.01, 0.001]}) clf.fit(a_in, a_out)
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())
def test_HorizontalKernel(self): self._run( MLPR(layers=[ C("Rectifier", channels=4, kernel_shape=(1, 16)), L("Linear") ], n_iter=1))
def test_Regressor(self): a_in = numpy.random.uniform(0.0, 1.0, (64, 16)) a_out = numpy.zeros((64, 1)) cross_val_score(MLPR(layers=[L("Linear")], n_iter=1), a_in, a_out, cv=5)
def test_ValidationSet(self): self._run( MLPR(layers=[ C("Rectifier", channels=4, kernel_shape=(3, 3)), L("Linear") ], n_iter=1, valid_size=0.5))
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.called = 0 self.value = 1.0 self.nn = MLPR(layers=[L("Linear")], n_iter=1, batch_size=1, callback={'on_batch_start': self._mutate_fn})
def setUp(self): self.nn = MLPR(layers=[ C("Rectifier", channels=6, kernel_shape=(3, 3)), C("Sigmoid", channels=4, kernel_shape=(5, 5)), C("Tanh", channels=8, kernel_shape=(3, 3)), L("Linear") ], n_iter=1)
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_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_GetParamsThenConstructor(self): nn1 = MLPR(layers=[L("Linear")], n_iter=1) a_in, a_out = numpy.zeros((8, 16)), numpy.zeros((8, 4)) nn1._initialize(a_in, a_out) p1 = nn1.get_parameters() print(len(p1)) nn2 = MLPR(layers=[L("Linear")], n_iter=1, parameters=p1) nn2._initialize(a_in, a_out) p2 = nn2.get_parameters() print(len(p2)) assert_true( (p1[0].weights.astype('float32') == p2[0].weights.astype('float32') ).all()) assert_true( (p1[0].biases.astype('float32') == p2[0].biases.astype('float32') ).all())
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 test_VerticalVerbose(self): self._run( MLPR(layers=[ C("Rectifier", channels=4, kernel_shape=(16, 1)), L("Linear") ], n_iter=1, verbose=1, valid_size=0.1))
def test_MultipleLayers(self): self._run( MLPR(layers=[ C("Rectifier", channels=6, kernel_shape=(3, 3)), C("Rectifier", channels=4, kernel_shape=(5, 5)), C("Rectifier", channels=8, kernel_shape=(3, 3)), 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)