def test_record_bad(): """ Tests that when we record a sequence of events, then do something different on playback, the Record class catches it. """ # Record a sequence of events output = StringIO() recorder = Record(file_object=output, replay=False) num_lines = 10 for i in xrange(num_lines): recorder.handle_line(str(i) + '\n') # Make sure that the playback functionality doesn't raise any errors # when we repeat some of them output_value = output.getvalue() output = StringIO(output_value) playback_checker = Record(file_object=output, replay=True) for i in xrange(num_lines // 2): playback_checker.handle_line(str(i) + '\n') # Make sure it raises an error when we deviate from the recorded sequence try: playback_checker.handle_line('0\n') except MismatchError: return raise AssertionError("Failed to detect mismatch between recorded sequence " " and repetition of it.")
def test_record_good(): """ Tests that when we record a sequence of events, then repeat it exactly, the Record class: 1) Records it correctly 2) Does not raise any errors """ # Record a sequence of events output = StringIO() recorder = Record(file_object=output, replay=False) num_lines = 10 for i in xrange(num_lines): recorder.handle_line(str(i) + '\n') # Make sure they were recorded correctly output_value = output.getvalue() assert output_value == ''.join(str(i) + '\n' for i in xrange(num_lines)) # Make sure that the playback functionality doesn't raise any errors # when we repeat them output = StringIO(output_value) playback_checker = Record(file_object=output, replay=True) for i in xrange(num_lines): playback_checker.handle_line(str(i) + '\n')
def test_record_mode_bad(): """ Like test_record_bad, but some events are recorded by the theano RecordMode, as is the event that triggers the mismatch error. """ # Record a sequence of events output = StringIO() recorder = Record(file_object=output, replay=False) record_mode = RecordMode(recorder) i = iscalar() f = function([i], i, mode=record_mode, name='f') num_lines = 10 for i in xrange(num_lines): recorder.handle_line(str(i) + '\n') f(i) # Make sure that the playback functionality doesn't raise any errors # when we repeat them output_value = output.getvalue() output = StringIO(output_value) playback_checker = Record(file_object=output, replay=True) playback_mode = RecordMode(playback_checker) i = iscalar() f = function([i], i, mode=playback_mode, name='f') for i in xrange(num_lines // 2): playback_checker.handle_line(str(i) + '\n') f(i) # Make sure a wrong event causes a MismatchError try: f(0) except MismatchError: return raise AssertionError("Failed to detect a mismatch.")
def test_record_mode_good(): """ Like test_record_good, but some events are recorded by the theano RecordMode. We don't attempt to check the exact string value of the record in this case. """ # Record a sequence of events output = StringIO() recorder = Record(file_object=output, replay=False) record_mode = RecordMode(recorder) i = iscalar() f = function([i], i, mode=record_mode, name='f') num_lines = 10 for i in xrange(num_lines): recorder.handle_line(str(i) + '\n') f(i) # Make sure that the playback functionality doesn't raise any errors # when we repeat them output_value = output.getvalue() output = StringIO(output_value) playback_checker = Record(file_object=output, replay=True) playback_mode = RecordMode(playback_checker) i = iscalar() f = function([i], i, mode=playback_mode, name='f') for i in xrange(num_lines): playback_checker.handle_line(str(i) + '\n') f(i)
def test_determinism(): """ Tests that apply nodes are all passed inputs with the same md5sums, apply nodes are run in same order, etc. Uses disturb_mem to try to cause dictionaries to iterate in different orders, etc. """ def run_bgd(mode): # Must be seeded the same both times run_bgd is called disturb_mem.disturb_mem() rng = np.random.RandomState([2012, 11, 27, 8]) batch_size = 5 train_batches = 3 valid_batches = 4 num_features = 2 # Synthesize dataset with a linear decision boundary w = rng.randn(num_features) def make_dataset(num_batches): disturb_mem.disturb_mem() m = num_batches * batch_size X = rng.randn(m, num_features) y = np.zeros((m, 1)) y[:, 0] = np.dot(X, w) > 0. rval = DenseDesignMatrix(X=X, y=y) rval.yaml_src = "" # suppress no yaml_src warning X = rval.get_batch_design(batch_size) assert X.shape == (batch_size, num_features) return rval train = make_dataset(train_batches) valid = make_dataset(valid_batches) num_chunks = 10 chunk_width = 2 class ManyParamsModel(Model): """ Make a model with lots of parameters, so that there are many opportunities for their updates to get accidentally re-ordered non-deterministically. This makes non-determinism bugs manifest more frequently. """ def __init__(self): super(ManyParamsModel, self).__init__() self.W1 = [ sharedX(rng.randn(num_features, chunk_width)) for i in xrange(num_chunks) ] disturb_mem.disturb_mem() self.W2 = [ sharedX(rng.randn(chunk_width)) for i in xrange(num_chunks) ] self._params = safe_union(self.W1, self.W2) self.input_space = VectorSpace(num_features) self.output_space = VectorSpace(1) disturb_mem.disturb_mem() model = ManyParamsModel() disturb_mem.disturb_mem() class LotsOfSummingCost(Cost): """ Make a cost whose gradient on the parameters involves summing many terms together, so that T.grad is more likely to sum things in a random order. """ supervised = True def expr(self, model, data, **kwargs): self.get_data_specs(model)[0].validate(data) X, Y = data disturb_mem.disturb_mem() def mlp_pred(non_linearity): Z = [T.dot(X, W) for W in model.W1] H = [non_linearity(z) for z in Z] Z = [T.dot(h, W) for h, W in safe_izip(H, model.W2)] pred = sum(Z) return pred nonlinearity_predictions = map( mlp_pred, [T.nnet.sigmoid, T.nnet.softplus, T.sqr, T.sin]) pred = sum(nonlinearity_predictions) disturb_mem.disturb_mem() return abs(pred - Y[:, 0]).sum() def get_data_specs(self, model): data = CompositeSpace( (model.get_input_space(), model.get_output_space())) source = (model.get_input_source(), model.get_target_source()) return (data, source) cost = LotsOfSummingCost() disturb_mem.disturb_mem() algorithm = BGD(cost=cost, batch_size=batch_size, updates_per_batch=5, scale_step=.5, conjugate=1, reset_conjugate=0, monitoring_dataset={ 'train': train, 'valid': valid }, termination_criterion=EpochCounter(max_epochs=5)) disturb_mem.disturb_mem() train_object = Train(dataset=train, model=model, algorithm=algorithm, save_freq=0) disturb_mem.disturb_mem() train_object.main_loop() output = cStringIO() record = Record(file_object=output, replay=False) record_mode = RecordMode(record) run_bgd(record_mode) output = cStringIO(output.getvalue()) playback = Record(file_object=output, replay=True) playback_mode = RecordMode(playback) run_bgd(playback_mode)