def __init__(self, rnn_type, consolidate_moment, consolidate_threshold, nin, nout, ninp, nhid, nlayers, max_memory_size, max_ltm_size, init_stm_size, lr, batch_size, clip, optimizer, ltm_reinstatement, stm_consolidation, train_weights_before_predict, weights_trainer, residual_weights_trainer=None, tie_weights=False, w_window=20, recent_window_size=5, dropout=0.2, is_cuda = True): self.optimizers = [] self.consolidate_moment = consolidate_moment self.consolidation_threshold = consolidate_threshold self.reinstatement_threshold = consolidate_threshold self.consolidate_moment_ticks = 1 self.residual_weights_trainer = None self.ltm_size = 0 self.memory_size = 0 self.max_ltm_size = max_ltm_size self.init_stm_size = init_stm_size self.max_memory_size = max_memory_size self.stm_consolidation = stm_consolidation self.ltm_reinstatement = ltm_reinstatement self.recent_window_size = recent_window_size self.weight_history = [] self.weights_copied = Observable() self.weights_moved = Observable() self.ltm_size_updated = Observable() super(CloneLearner, self).__init__(rnn_type, nin, nout, ninp, nhid, nlayers, max_memory_size, lr, batch_size, clip, optimizer, train_weights_before_predict, weights_trainer, tie_weights, w_window, dropout, is_cuda) self.weights_updated.register(self.save_weights_history)
def __init__(self, rnn_type, nin, nout, ninp, nhid, nlayers, max_memory_size, lr, batch_size, clip, optimizer, train_weights_before_predict, weights_trainer, learn_iterations, tie_weights, w_window, dropout, is_cuda): criterion = nn.CrossEntropyLoss() super(BaseMixtureOfRNNsLearner, self).__init__(criterion, nout, learn_iterations) self.optimizer_algorithm = optimizer #general parameters self.rnn_type = rnn_type self.nin = nin self.nout = nout self.ninp = ninp self.nhid = nhid self.max_memory_size = max_memory_size self.dropout = dropout self.rnns = [] self.ids = [] self.id_count = 0 self.lr = lr self.batch_size = batch_size self.hidden = [] self.clip = clip self.window_size = w_window self.nlayers = nlayers self.train_weights_before_predict = train_weights_before_predict self.cuda_available = is_cuda self.outputs = torch.zeros(self.max_memory_size, 20, self.batch_size, self.nout) self.weights_trainer = weights_trainer self.tie_weights = tie_weights self.weights_added = Observable() self.weights_removed = Observable() self.weights_updated = Observable() self._initialize_model()
def test_many_events_with_dictionary(): subject = Observable() subject.on({ # setting events of an observable with dictionary 'one': one_handler, 'two': two_handler, 'custom': CustomEvent(), 'many': [one_handler, two_handler]}) subject.trigger('one two custom many', 1, 2, a=3, b=4)
def test_custom_event(): subject = Observable() custom_event = CustomEvent() subject.on('custom', custom_event) subject.on(['custom', 'custom_alias'], custom_event) # same reference assert(subject.custom and subject.custom_alias is custom_event) assert(one_handler and two_handler in subject.custom.handlers) # update an event subject.on('custom', CustomEvent()) assert(subject.custom is not custom_event)
def test_event_with_many_handlers_attached(): subject = Observable() subject.on('many', [one_handler, two_handler]) assert(subject.events['many'] is subject.many) assert(one_handler and two_handler in subject.many.handlers) # remove a handler subject.off('many', one_handler) assert(one_handler not in subject.many.handlers) # remove the event subject.off('many') assert('many' not in subject.events) with raises(AttributeError): subject.many
def test_event_with_handler_attached(): subject = Observable() subject.on('one', one_handler) subject.on('two', two_handler) assert(subject.events['one'] is subject.one) assert(subject.events['two'] is subject.two) # trigger subject.one(1, 2, a=3, b=4) subject.one.trigger(1, 2, a=3, b=4) subject.trigger('one', 1, 2, a=3, b=4) subject.events['one'].trigger(1, 2, a=3, b=4) subject.trigger('one two', 1, 2, a=3, b=4) subject.trigger(['one', 'two'], 1, 2, a=3, b=4)
def test_update(self): observable = Observable() observer = Observer(1) observable.addObserver(observer) observable.updateObservers(2) self.assertEqual(observer.data, 2)
"""Alarm Event names""" from observer import Observable import logging LOGGER = logging.getLogger('alarm') # Events MOTION_DETECTED = 'motion_detected' # Basic handlers def log_it(*args, **kwargs): LOGGER.debug("%s, %s", args, kwargs) # Setup events observable = Observable() observable.on(MOTION_DETECTED, [log_it])
def test_no_callable_handler(): subject = Observable() with raises(TypeError): subject.on('error', NotCallable())
def test_events_with_same_handlers_attached(): subject = Observable() subject.on('many many2', [one_handler, two_handler]) assert(subject.many is not subject.many2) assert(one_handler and two_handler in subject.many.handlers) assert(one_handler and two_handler in subject.many2.handlers)
def test_events_with_same_handler_attached(): subject = Observable() subject.on(['one', 'one2'], one_handler) assert(subject.one is not subject.one2) assert(one_handler in subject.one.handlers) assert(one_handler in subject.one2.handlers)
############################################################################### # Build the model ############################################################################### vocsize = len(corpora.vocabulary) print('Vocabulary size:', vocsize) print('Creating learner...') learner = get_learner(args, vocsize) print(f'Number of parameters: {learner.get_num_parameters()/1e6:1.2f}M') if args.cuda: learner.cuda() if args.load_from: learner.load_from(torch.load(args.load_from)) domain_switched = Observable() timestep_updated = Observable() learner.train_mode() if args.log_weights: weight_logger = log_utils.WeightsLogger(learner, args.log_weights) domain_switched.register(weight_logger.domain_switched) timestep_updated.register(weight_logger.timestep_updated) ############################################################################### # Training code ############################################################################### def generate_text(sequence_id, position, sequence_type, sequence_type_name): learner.evaluate_mode() input = Variable(torch.rand(1, 1).mul(len(corpora.vocabulary)).long(),
self.plotly_user_config['plotly_streaming_tokens'][0]) self.stream.open() def notify(self, observable, *args, **kwargs): # write to plotly if 'value' in kwargs: # self.stream.write({'x': datetime.datetime.now(), 'y': kwargs['value']}) self.stream.write({'x': kwargs['timestamp'], 'y': kwargs['value']}) # import plotly.plotly as py # from plotly.graph_objs import * # trace0 = Scatter( # x=[1, 2, 3, 4], # y=[10, 15, 13, 17] # ) # trace1 = Scatter( # x=[1, 2, 3, 4], # y=[16, 5, 11, 9] # ) # data = Data([trace0, trace1]) # unique_url = py.plot(data, filename = 'basic-line') if __name__ == '__main__': subject = Observable() plyobs = plotlyObserver(subject, 'config.json', 'test stream plot') subject.notify_observers(value=45) subject.notify_observers(value=55)