Ejemplo n.º 1
0
 def increment_n_map_entries(self):
     """
     Add one to ``n_map`` entries and grow the bundle map as needed.
     """
     self.n_map_entries += 1
     if self.n_map_entries >= self.bundle_map_size:
         self.bundle_map_size *= 2
         self.bundle_map_rows = tools.pad(self.bundle_map_rows, 
                                          self.bundle_map_size, 
                                          val=-1, dtype='int')
         self.bundle_map_cols = tools.pad(self.bundle_map_cols, 
                                          self.bundle_map_size, 
                                          val=-1, dtype='int')
Ejemplo n.º 2
0
    def add_cables(self, num_new_cables):
        """ Add new cables to the hub when new gearboxes are created """
        self.num_cables = self.num_cables + num_new_cables
        features_shape = (self.num_cables, 1)
        transition_shape = (self.num_cables, self.num_cables)
        self.reward = tools.pad(self.reward,
                                transition_shape,
                                val=self.INITIAL_REWARD)

        for index in range(len(self.activity_history)):
            self.activity_history[index] = tools.pad(
                self.activity_history[index], features_shape)
            self.action_history[index] = tools.pad(self.action_history[index],
                                                   features_shape)
Ejemplo n.º 3
0
    def add_cables(self, num_new_cables):
        """ Add new cables to the hub when new blocks are created """ 
        self.num_cables = self.num_cables + num_new_cables
        self.expected_reward = tools.pad(self.expected_reward, 
                                      (self.num_cables, self.num_cables), 
                                      val=self.INITIAL_REWARD)
        self.cable_activities = tools.pad(self.cable_activities, 
                                          (self.num_cables, 1))

        self.count = tools.pad(self.count, (self.num_cables, self.num_cables))
        # All the cable activities from all the blocks, at the current time
        for index in range(len(self.pre)):
            self.pre[index] = tools.pad(self.pre[index], (self.num_cables, 1))
            self.post[index] = tools.pad(self.post[index], (self.num_cables, 1))
Ejemplo n.º 4
0
 def increment_n_map_entries(self):
     """
     Add one to ``n_map`` entries and grow the bundle map as needed.
     """
     self.n_map_entries += 1
     if self.n_map_entries >= self.bundle_map_size:
         self.bundle_map_size *= 2
         self.bundle_map_rows = tools.pad(self.bundle_map_rows,
                                          self.bundle_map_size,
                                          val=-1,
                                          dtype='int')
         self.bundle_map_cols = tools.pad(self.bundle_map_cols,
                                          self.bundle_map_size,
                                          val=-1,
                                          dtype='int')
Ejemplo n.º 5
0
    def add_cables(self, num_new_cables):
        """ Add new cables to the hub when new blocks are created """
        self.num_cables = self.num_cables + num_new_cables
        self.expected_reward = tools.pad(self.expected_reward,
                                         (self.num_cables, self.num_cables),
                                         val=self.INITIAL_REWARD)
        self.cable_activities = tools.pad(self.cable_activities,
                                          (self.num_cables, 1))

        self.count = tools.pad(self.count, (self.num_cables, self.num_cables))
        # All the cable activities from all the blocks, at the current time
        for index in range(len(self.pre)):
            self.pre[index] = tools.pad(self.pre[index], (self.num_cables, 1))
            self.post[index] = tools.pad(self.post[index],
                                         (self.num_cables, 1))
Ejemplo n.º 6
0
 def step_down(self, bundle_goals):
     """ Find cable_activity_goals, given a set of bundle_goals """
     bundle_goals = tools.pad(bundle_goals, (self.max_bundles, 1))
     cable_goals = np.zeros((self.max_cables, 1))
     self.surprise = np.zeros((self.max_cables, 1))
     # Process the downward pass of each of the cogs in the level
     cog_index = 0
     for cog in self.cogs:
         # Gather the goal inputs for each cog
         cog_bundle_goals = bundle_goals[
             cog_index * self.max_bundles_per_cog:cog_index +
             1 * self.max_bundles_per_cog, :]
         # Update the downward outputs for the level
         cable_goals_by_cog = cog.step_down(cog_bundle_goals)
         cog_cable_indices = self.ziptie.get_index_projection(
             cog_index).ravel().astype(bool)
         cable_goals[cog_cable_indices] = np.maximum(
             cable_goals_by_cog, cable_goals[cog_cable_indices])
         #self.reaction[cog_cable_indices] = np.maximum(
         #        tools.pad(cog.reaction, (cog_cable_indices[0].size, 0)),
         #        self.reaction[cog_cable_indices])
         self.surprise[cog_cable_indices] = np.maximum(
             cog.surprise, self.surprise[cog_cable_indices])
         cog_index += 1
     #self.hub_cable_goals = tools.bounded_sum([self.hub_cable_goals,
     #                                          cable_goals])
     return self.hub_cable_goals
Ejemplo n.º 7
0
 def step_down(self, bundle_goals):
     """ Find cable_activity_goals, given a set of bundle_goals """
     bundle_goals = tools.pad(bundle_goals, (self.max_bundles, 1))
     cable_goals = np.zeros((self.max_cables, 1))
     self.surprise = np.zeros((self.max_cables, 1))
     # Process the downward pass of each of the cogs in the level
     cog_index = 0
     for cog in self.cogs:
         # Gather the goal inputs for each cog
         cog_bundle_goals = bundle_goals[
                 cog_index * self.max_bundles_per_cog:
                 cog_index + 1 * self.max_bundles_per_cog,:]
         # Update the downward outputs for the level 
         cable_goals_by_cog = cog.step_down(cog_bundle_goals)
         cog_cable_indices = self.ziptie.get_index_projection(
                 cog_index).ravel().astype(bool)
         cable_goals[cog_cable_indices] = np.maximum(
                 cable_goals_by_cog, cable_goals[cog_cable_indices]) 
         #self.reaction[cog_cable_indices] = np.maximum(
         #        tools.pad(cog.reaction, (cog_cable_indices[0].size, 0)),
         #        self.reaction[cog_cable_indices]) 
         self.surprise[cog_cable_indices] = np.maximum(
                 cog.surprise, self.surprise[cog_cable_indices]) 
         cog_index += 1
     #self.hub_cable_goals = tools.bounded_sum([self.hub_cable_goals, 
     #                                          cable_goals])
     return self.hub_cable_goals 
Ejemplo n.º 8
0
 def add_cables(self, num_new_cables):
     """ 
     Add new cables to the hub when new gearboxes are created 
     """ 
     self.num_cables += num_new_cables
     features_shape = (self.num_cables, 1)
     self.time_since_seen = tools.pad(self.time_since_seen, features_shape,
                                      val=tools.BIG)
Ejemplo n.º 9
0
 def add_cables(self, num_new_cables):
     """ 
     Add new cables to the hub when new gearboxes are created 
     """ 
     self.num_cables = self.num_cables + num_new_cables
     transition_shape = (self.num_cables, self.num_actions)
     #self.value = tools.pad(self.value, transition_shape)
     self.reward = tools.pad(self.reward, transition_shape)
Ejemplo n.º 10
0
    def __init__(self,
                 events,
                 print_summary=True,
                 model=None,
                 load=None,
                 njets=10):
        """
        A class for neural networks that take raw pt, eta, phi values
        """
        print("INITIALIZING NN")
        # get events, split into subsets
        self.njets = njets
        self.events = tools.pad(events, length=self.njets)
        self.train, self.val, self.test = tools.splitTVT(self.events,
                                                         trainfrac=0.7,
                                                         testfrac=0.2)

        # create network
        if load:
            jsonfile, h5file = load
            print("loading model. \nUsing architecture:", jsonfile,
                  "and weights:", h5file)
            with open(jsonfile, 'rb') as f:
                model_json = f.read()
            self.model = model_from_json(model_json)
            self.model.load_weights(h5file)
        elif model is None:
            print("creating default model")
            self.model = Sequential([
                Dense(3 * (njets - 3),
                      input_dim=3 * (njets - 3),
                      kernel_initializer='normal',
                      activation='relu'),
                Dense(700, activation='relu'),
                Dropout(0.1),
                Dense(500, activation='relu'),
                Dropout(0.1),
                Dense(300, activation='relu'),
                Dropout(0.1),
                Dense(100, activation='relu'),
                Dropout(0.1),
                Dense(50, activation='relu'),
                Dense(
                    njets - 3 + 1,  # - 3 correctly tagged + 1 for no jet
                    kernel_initializer='normal',
                    activation='softmax')
            ])
            optimizer = Adam(lr=5e-5)
            self.model.compile(loss='categorical_crossentropy',
                               optimizer=optimizer,
                               metrics=['acc'])
        else:
            print("using input model")
            self.model = model
        if print_summary:
            self.model.summary()
        # format inputs to NN by scaling
        self.s_in = tools.scale_nn_input(self.events, chop=3, pad=self.njets)
Ejemplo n.º 11
0
    def update(self, cable_activities, reward):        
        """ Train the daisychain using the current cable_activities 
        and reward """
        self.num_cables = np.maximum(self.num_cables, cable_activities.size)
        # Pad the incoming cable_activities array out to its full size 
        cable_activities = tools.pad(cable_activities, 
                                     (self.max_num_cables, 0))
        self.current_reward = reward
        # The pre is a weighted sum of previous cable_activities, with the most
        # recent cable_activities being weighted the highest
        # debug
        #self.pre = tools.bounded_sum([
        #        self.post, self.pre * (1 - self.PRE_DECAY_RATE)])
        self.pre = self.post
        self.post = cable_activities
        chain_activities = self.pre * self.post.T
        chain_activities[np.nonzero(np.eye(self.pre.size))] = 0.
        update_rate_raw = (chain_activities * 
                           ((1 - self.CHAIN_UPDATE_RATE) / 
                            (self.count + tools.EPSILON) + 
                            self.CHAIN_UPDATE_RATE))
        update_rate = np.minimum(0.5, update_rate_raw)
        self.count += chain_activities
        self.count -= 1 / (self.AGING_TIME_CONSTANT * self.count + 
                           tools.EPSILON)
        self.count = np.maximum(self.count, 0)
        reward_difference = np.abs(reward - self.reward_value)
        self.reward_value += (reward - self.reward_value) * update_rate
        self.reward_uncertainty += (reward_difference - 
                                    self.reward_uncertainty) * update_rate
        update_rate_raw_post = (self.pre * ((1 - self.CHAIN_UPDATE_RATE) / 
                                            (self.pre_count + tools.EPSILON) + 
		                                    self.CHAIN_UPDATE_RATE)) 
        update_rate_post = np.minimum(0.5, update_rate_raw_post)
        self.pre_count += self.pre
        self.pre_count -= 1 / (self.AGING_TIME_CONSTANT * self.pre_count +
                               tools.EPSILON)
        self.pre_count = np.maximum(self.pre_count, 0)
        post_difference = np.abs(self.pre * self.post.T - self.expected_post)
        self.expected_post += (self.pre * self.post.T - 
		               self.expected_post) * update_rate_post
        self.post_uncertainty += (post_difference - 
                                  self.post_uncertainty) * update_rate_post 
        # Reaction is the expected post, turned into a deliberation_vote
        self.reaction = tools.weighted_average(self.expected_post, self.pre)
        # Surprise is the difference between the expected post and
        # the actual one
        self.surprise = tools.weighted_average(
                np.abs(self.post.T - self.expected_post), 
		        self.pre / (self.post_uncertainty + tools.EPSILON))
        #self.surprise = tools.weighted_average(
        #        np.abs((self.post.T - self.expected_post) / 
		#               (self.post_uncertainty + tools.EPSILON)), 
		#        self.pre / (self.post_uncertainty + tools.EPSILON))
        # Reshape chain activities into a single column
        return chain_activities.ravel()[:,np.newaxis]
Ejemplo n.º 12
0
    def grow(self, increment):
        """
        Grow the ``Amygdala``.

        Parameters
        ----------
        increment : int
            The number of features to add.
        """
        self.reward_by_feature = tools.pad(self.reward_by_feature, -increment)
Ejemplo n.º 13
0
    def grow(self, increment):
        """
        Grow the ``Amygdala``.

        Parameters
        ----------
        increment : int
            The number of features to add.
        """
        self.reward_by_feature = tools.pad(self.reward_by_feature, -increment)
Ejemplo n.º 14
0
    def grow(self, increment):
        """
        Grow the ``Ganglia``.

        Parameters
        ----------
        increment : int
            The number of features to add.
        """
        self.num_features += increment
        self.num_elements += increment
        self.goals = tools.pad(self.goals, self.num_features)
Ejemplo n.º 15
0
    def grow(self, increment):
        """
        Grow the ``Ganglia``.

        Parameters
        ----------
        increment : int
            The number of features to add.
        """
        self.num_features += increment
        self.num_elements += increment
        self.goals = tools.pad(self.goals, self.num_features)
Ejemplo n.º 16
0
    def grow(self, increment):
        """
        Grow the ``Cerebellum``.

        Parameters
        ----------
        increment : int
            The number of features to add.

        Returns
        -------
        None
        """
        self.num_elements += increment
        self.num_features += increment
        _2D_size = (self.num_features, self.num_elements)
        _3D_size = (self.num_features, self.num_elements, self.num_features)
        self.observations = tools.pad(self.observations, _3D_size)
        self.opportunities = tools.pad(self.opportunities, _2D_size, 
                                       val=tools.epsilon)
        self.curiosities = tools.pad(self.curiosities, _2D_size)
        self.live_elements = tools.pad(self.live_elements, self.num_elements)

        for i in np.arange(len(self.features_history)):
            self.features_history[i] = tools.pad(self.features_history[i], 
                                                 self.num_features)
        for i in np.arange(len(self.goals_history)):
            if self.goals_history[i] is not None:
                self.goals_history[i] = tools.pad(self.goals_history[i], 
                                                  self.num_elements)
Ejemplo n.º 17
0
    def grow(self, increment):
        """
        Grow the ``Cerebellum``.

        Parameters
        ----------
        increment : int
            The number of features to add.

        Returns
        -------
        None
        """
        self.num_elements += increment
        self.num_features += increment
        _2D_size = (self.num_features, self.num_elements)
        _3D_size = (self.num_features, self.num_elements, self.num_features)
        self.observations = tools.pad(self.observations, _3D_size)
        self.opportunities = tools.pad(self.opportunities,
                                       _2D_size,
                                       val=tools.epsilon)
        self.curiosities = tools.pad(self.curiosities, _2D_size)
        self.live_elements = tools.pad(self.live_elements, self.num_elements)

        for i in np.arange(len(self.features_history)):
            self.features_history[i] = tools.pad(self.features_history[i],
                                                 self.num_features)
        for i in np.arange(len(self.goals_history)):
            if self.goals_history[i] is not None:
                self.goals_history[i] = tools.pad(self.goals_history[i],
                                                  self.num_elements)
Ejemplo n.º 18
0
    def data_encry_pack(self,data_pack):
        
        key_iv = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        key_iv_pack = struct.pack('%dB'%len(key_iv), *key_iv)
        key_pack= struct.pack('%dB'%len(self.sess_key), *self.sess_key)
        #print '***********sess_key_pack',binascii.hexlify(key_pack)
        ackBody_AES = AES.new(key_pack, AES.MODE_CBC, key_iv_pack)
#        print 'ack_Packet_data before AES',binascii.hexlify(data_pack)
        data_encryed=ackBody_AES.encrypt(tools.pad(data_pack))
#        print 'ack_Packet_data after AES',binascii.hexlify(data_encryed)
        self.msg_len=len(data_encryed)
#        print 'ack_Packet msg_len after AES',self.msg_len
        return data_encryed 
Ejemplo n.º 19
0
    def step_down(self, bundle_goals):
        """ 
        Project the bundle goal values to the appropriate cables

        Multiply the bundle goals across the cables that contribute 
        to them, and perform a bounded sum over all bundles to get 
        the estimated activity associated with each cable.
        """
        if bundle_goals.size > 0:
            bundle_goals = tools.pad(bundle_goals, (self.max_num_bundles, 0))
            cable_activity_goals = tools.bounded_sum(self.bundle_map * 
                                                     bundle_goals, axis=0)
        else:
            cable_activity_goals = np.zeros((self.max_num_cables, 1))
        return cable_activity_goals
Ejemplo n.º 20
0
    def recognize(self,
                  images,
                  detection_kwargs=None,
                  recognition_kwargs=None):
        """Run the pipeline on one or multiples images.

        Args:
            images: The images to parse (can be a list of actual images or a list of filepaths)
            detection_kwargs: Arguments to pass to the detector call
            recognition_kwargs: Arguments to pass to the recognizer call

        Returns:
            A list of lists of (text, box) tuples.
        """

        # Make sure we have an image array to start with.
        if not isinstance(images, np.ndarray):
            images = [tools.read(image) for image in images]
        # This turns images into (image, scale) tuples temporarily
        images = [
            tools.resize_image(image,
                               max_scale=self.scale,
                               max_size=self.max_size) for image in images
        ]
        max_height, max_width = np.array(
            [image.shape[:2] for image, scale in images]).max(axis=0)
        scales = [scale for _, scale in images]
        images = np.array([
            tools.pad(image, width=max_width, height=max_height)
            for image, _ in images
        ])
        if detection_kwargs is None:
            detection_kwargs = {}
        if recognition_kwargs is None:
            recognition_kwargs = {}
        box_groups = self.detector.detect(images=images, **detection_kwargs)
        prediction_groups = self.recognizer.recognize_from_boxes(
            images=images, box_groups=box_groups, **recognition_kwargs)
        box_groups = [
            tools.adjust_boxes(
                boxes=boxes, boxes_format='boxes', scale=1 /
                scale) if scale != 1 else boxes
            for boxes, scale in zip(box_groups, scales)
        ]
        return [
            list(zip(predictions, boxes))
            for predictions, boxes in zip(prediction_groups, box_groups)
        ]
Ejemplo n.º 21
0
    def step_down(self, bundle_goals):
        """ 
        Project the bundle goal values to the appropriate cables

        Multiply the bundle goals across the cables that contribute 
        to them, and perform a bounded sum over all bundles to get 
        the estimated activity associated with each cable.
        """
        if bundle_goals.size > 0:
            bundle_goals = tools.pad(bundle_goals, (self.max_num_bundles, 0))
            cable_activity_goals = tools.bounded_sum(self.bundle_map *
                                                     bundle_goals,
                                                     axis=0)
        else:
            cable_activity_goals = np.zeros((self.max_num_cables, 1))
        return cable_activity_goals
Ejemplo n.º 22
0
 def step_up(self, cable_activities, enough_cables):
     """ cable_activities percolate upward through daisychain and ziptie """
     # TODO: fix this so that cogs can gracefully handle more cables 
     # or else never be assigned them in the first place
     if cable_activities.size > self.max_cables:
         cable_activities = cable_activities[:self.max_cables, :]
         print '-----  Number of max cables exceeded in', self.name, \
                 '  -----'
     chain_activities = self.daisychain.step_up(cable_activities)
     self.surprise = self.daisychain.get_surprise()
     if enough_cables is True:
         bundle_activities = self.ziptie.step_up(chain_activities)
     else:
         bundle_activities = np.zeros((0,1))
     bundle_activities = tools.pad(bundle_activities, (self.max_bundles, 0))
     return bundle_activities
Ejemplo n.º 23
0
Archivo: cog.py Proyecto: 00mjk/becca
 def step_up(self, cable_activities, enough_cables):
     """ Cable_activities percolate upward through daisychain and ziptie """
     # TODO: fix this so that cogs can gracefully handle more cables
     # or else never be assigned them in the first place
     if cable_activities.size > self.max_cables:
         cable_activities = cable_activities[:self.max_cables, :]
         print '-----  Number of max cables exceeded in', self.name, \
                 '  -----'
     chain_activities = self.daisychain.step_up(cable_activities)
     self.surprise = self.daisychain.get_surprise()
     if enough_cables is True:
         bundle_activities = self.ziptie.step_up(chain_activities)
     else:
         bundle_activities = np.zeros((0, 1))
     bundle_activities = tools.pad(bundle_activities, (self.max_bundles, 0))
     return bundle_activities
Ejemplo n.º 24
0
 def step_up(self, new_cable_activities):
     """ Find bundle_activities that result from new_cable_activities """
     # Condition the cable activities to fall between 0 and 1
     if new_cable_activities.size < self.max_cables:
         new_cable_activities = tools.pad(new_cable_activities, 
                                          (self.max_cables, 1))
     # Update cable_activities
     self.raw_cable_activities *= 1. - (self.ACTIVITY_DECAY_RATE /
                                        float(self.step_multiplier))
     self.raw_cable_activities += new_cable_activities
     self.step_counter += 1
     if self.step_counter < self.step_multiplier:
         return self.bundle_activities
     self.min_vals = np.minimum(self.raw_cable_activities, self.min_vals)
     self.max_vals = np.maximum(self.raw_cable_activities, self.max_vals)
     spread = self.max_vals - self.min_vals
     self.cable_activities = ((self.raw_cable_activities - self.min_vals) / 
                (self.max_vals - self.min_vals + tools.EPSILON))
     self.min_vals += spread * self.RANGE_DECAY_RATE
     self.max_vals -= spread * self.RANGE_DECAY_RATE
     cluster_training_activities = np.maximum(
             self.previous_cable_activities, self.cable_activities)
     self.previous_cable_activities = self.cable_activities.copy() 
     # Update the map from self.cable_activities to cogs
     self.ziptie.step_up(cluster_training_activities)
     # Process the upward pass of each of the cogs in the gearbox
     self.bundle_activities = np.zeros((0, 1))
     for cog_index in range(len(self.cogs)):
         # Pick out the cog's cable_activities, process them, 
         # and assign the results to gearbox's bundle_activities
         cog_cable_activities = self.cable_activities[
                 self.ziptie.get_index_projection(
                 cog_index).astype(bool)]
         # Cogs are only allowed to start forming bundles once 
         # the number of cables exceeds the fill_fraction_threshold
         enough_cables = (self.ziptie.cable_fraction_in_bundle(cog_index)
                          > self.fill_fraction_threshold)
         cog_bundle_activities = self.cogs[cog_index].step_up(
                 cog_cable_activities, enough_cables)
         self.bundle_activities = np.concatenate((self.bundle_activities, 
                                                  cog_bundle_activities))
     # Goal fulfillment and decay
     self.hub_cable_goals -= self.cable_activities
     self.hub_cable_goals *= self.ACTIVITY_DECAY_RATE
     self.hub_cable_goals = np.maximum(self.hub_cable_goals, 0.)
     return self.bundle_activities
Ejemplo n.º 25
0
 def step_up(self, new_cable_activities):
     """ Find bundle_activities that result from new_cable_activities """
     # Condition the cable activities to fall between 0 and 1
     if new_cable_activities.size < self.max_cables:
         new_cable_activities = tools.pad(new_cable_activities,
                                          (self.max_cables, 1))
     # Update cable_activities
     self.raw_cable_activities *= 1. - (self.ACTIVITY_DECAY_RATE /
                                        float(self.step_multiplier))
     self.raw_cable_activities += new_cable_activities
     self.step_counter += 1
     if self.step_counter < self.step_multiplier:
         return self.bundle_activities
     self.min_vals = np.minimum(self.raw_cable_activities, self.min_vals)
     self.max_vals = np.maximum(self.raw_cable_activities, self.max_vals)
     spread = self.max_vals - self.min_vals
     self.cable_activities = (
         (self.raw_cable_activities - self.min_vals) /
         (self.max_vals - self.min_vals + tools.EPSILON))
     self.min_vals += spread * self.RANGE_DECAY_RATE
     self.max_vals -= spread * self.RANGE_DECAY_RATE
     cluster_training_activities = np.maximum(
         self.previous_cable_activities, self.cable_activities)
     self.previous_cable_activities = self.cable_activities.copy()
     # Update the map from self.cable_activities to cogs
     self.ziptie.step_up(cluster_training_activities)
     # Process the upward pass of each of the cogs in the gearbox
     self.bundle_activities = np.zeros((0, 1))
     for cog_index in range(len(self.cogs)):
         # Pick out the cog's cable_activities, process them,
         # and assign the results to gearbox's bundle_activities
         cog_cable_activities = self.cable_activities[
             self.ziptie.get_index_projection(cog_index).astype(bool)]
         # Cogs are only allowed to start forming bundles once
         # the number of cables exceeds the fill_fraction_threshold
         enough_cables = (self.ziptie.cable_fraction_in_bundle(cog_index) >
                          self.fill_fraction_threshold)
         cog_bundle_activities = self.cogs[cog_index].step_up(
             cog_cable_activities, enough_cables)
         self.bundle_activities = np.concatenate(
             (self.bundle_activities, cog_bundle_activities))
     # Goal fulfillment and decay
     self.hub_cable_goals -= self.cable_activities
     self.hub_cable_goals *= self.ACTIVITY_DECAY_RATE
     self.hub_cable_goals = np.maximum(self.hub_cable_goals, 0.)
     return self.bundle_activities
Ejemplo n.º 26
0
    def step_up(self, cable_activities):        
        """ 
        Train the daisychain using the current cable_activities
        """
        self.num_cables = np.maximum(self.num_cables, cable_activities.size)
        # Pad the incoming cable_activities array out to its full size 
        cable_activities = tools.pad(cable_activities, 
                                     (self.max_num_cables, 0))
        # Update cable_activities
        self.pre = self.cable_activities.copy()
        self.cable_activities = cable_activities.copy()
        self.post = self.cable_activities.copy()
        chain_activities = self.pre * self.post.T
        self.count += chain_activities
        #self.count -= 1 / (self.AGING_TIME_CONSTANT * self.count + 
        #                   tools.EPSILON)
        self.count = np.maximum(self.count, 0)
        update_rate_raw_post = (self.pre * ((1 - self.CHAIN_UPDATE_RATE) / 
                                            (self.pre_count + tools.EPSILON) + 
		                                    self.CHAIN_UPDATE_RATE)) 
        update_rate_post = np.minimum(0.5, update_rate_raw_post)
        self.pre_count += self.pre
        #self.pre_count -= 1 / (self.AGING_TIME_CONSTANT * self.pre_count +
        #                       tools.EPSILON)
        self.pre_count = np.maximum(self.pre_count, 0)
        #post_difference = np.abs(self.pre * self.post.T - 
        #                         self.expected_cable_activities)
        self.expected_cable_activities += update_rate_post * (
                self.pre * self.post.T - self.expected_cable_activities)
        #self.post_uncertainty += (post_difference - 
        #                          self.post_uncertainty) * update_rate_post 
        # Reaction is the expected post, turned into a deliberation_vote
        #self.reaction = tools.weighted_average(self.expected_cable_activities, 
        #                                       self.pre)
        # Surprise is the difference between the expected post and
        # the actual one
        #surprise_weights = (self.pre / (self.post_uncertainty + tools.EPSILON)
        #                    + tools.EPSILON)
        #self.surprise = tools.weighted_average(
        #        np.abs(self.post.T - self.expected_cable_activities),
        #        surprise_weights) 
        # Reshape chain activities into a single column
        #return (chain_activities.ravel()[:,np.newaxis], 
        #        self.reaction[:self.num_cables])
        return chain_activities.ravel()[:,np.newaxis]
Ejemplo n.º 27
0
    def _normalize(self, cable_activities):
        """
        Normalize activities so that they are predictably distrbuted.
        
        Use a running estimate of the maximum of each cable activity.
        Scale it so that the max would fall at 1.

        Normalization has several benefits. 
        1. It makes for fewer constraints on worlds and sensors. 
           Any sensor can return any range of values. 
        2. Gradual changes in sensors and the world can be adapted to.
        3. It makes the bundle creation heuristic more robust and
           predictable. The approximate distribution of cable 
           activities is known and can be designed for.

        Parameters
        ----------
        cable_activities : array of floats
            The current activity levels of the cables. 

        Returns
        -------
        normalized_cable_activities : array of floats
            The normalized activity levels of the cables.
        """
        if cable_activities.size < self.max_num_cables:
            cable_activities = tools.pad(cable_activities, self.max_num_cables)

        self.cable_max += ((cable_activities - self.cable_max) /
                           self.cable_max_decay_time)
        i_lo = np.where(cable_activities > self.cable_max)
        self.cable_max[i_lo] += (
            (cable_activities[i_lo] - self.cable_max[i_lo]) /
            self.cable_max_grow_time)
        cable_activities = cable_activities / (self.cable_max + tools.epsilon)
        cable_activities = np.maximum(0., cable_activities)
        cable_activities = np.minimum(1., cable_activities)

        # Sparsify the cable activities to speed up processing.
        cable_activities[np.where(
            cable_activities < self.activity_threshold)] = 0.

        normalized_cable_activities = cable_activities.copy()
        return normalized_cable_activities
Ejemplo n.º 28
0
    def _normalize(self, cable_activities):
        """
        Normalize activities so that they are predictably distrbuted.
        
        Use a running estimate of the maximum of each cable activity.
        Scale it so that the max would fall at 1.

        Normalization has several benefits. 
        1. It makes for fewer constraints on worlds and sensors. 
           Any sensor can return any range of values. 
        2. Gradual changes in sensors and the world can be adapted to.
        3. It makes the bundle creation heuristic more robust and
           predictable. The approximate distribution of cable 
           activities is known and can be designed for.

        Parameters
        ----------
        cable_activities : array of floats
            The current activity levels of the cables. 

        Returns
        -------
        normalized_cable_activities : array of floats
            The normalized activity levels of the cables.
        """
        if cable_activities.size < self.max_num_cables:
            cable_activities = tools.pad(cable_activities, self.max_num_cables)

        self.cable_max += ( (cable_activities - self.cable_max) / 
                            self.cable_max_decay_time ) 
        i_lo = np.where(cable_activities > self.cable_max)
        self.cable_max[i_lo] += ( (cable_activities[i_lo] - 
                                   self.cable_max[i_lo]) /
                                 self.cable_max_grow_time )  
        cable_activities = cable_activities / (self.cable_max + tools.epsilon)
        cable_activities = np.maximum(0., cable_activities)
        cable_activities = np.minimum(1., cable_activities)
        
        # Sparsify the cable activities to speed up processing.
        cable_activities[np.where(cable_activities < 
                                  self.activity_threshold)] = 0.

        normalized_cable_activities = cable_activities.copy()
        return normalized_cable_activities
Ejemplo n.º 29
0
    def step_up(self, new_cable_activities):
        """ Find bundle_activities that result from new_cable_activities """
        # Condition the cable activities to fall between 0 and 1
        if new_cable_activities.size < self.max_cables:
            new_cable_activities = tools.pad(new_cable_activities,
                                             (self.max_cables, 1))
        self.min_vals = np.minimum(new_cable_activities, self.min_vals)
        self.max_vals = np.maximum(new_cable_activities, self.max_vals)
        spread = self.max_vals - self.min_vals
        new_cable_activities = (
            (new_cable_activities - self.min_vals) /
            (self.max_vals - self.min_vals + tools.EPSILON))
        self.min_vals += spread * self.RANGE_DECAY_RATE
        self.max_vals -= spread * self.RANGE_DECAY_RATE
        # Update cable_activities, incorporating sensing dynamics
        self.cable_activities = tools.bounded_sum([
            new_cable_activities,
            self.cable_activities * (1. - self.ACTIVITY_DECAY_RATE)
        ])

        # Update the map from self.cable_activities to cogs
        self.ziptie.step_up(self.cable_activities)
        # Process the upward pass of each of the cogs in the block
        self.bundle_activities = np.zeros((0, 1))
        for cog_index in range(len(self.cogs)):
            # Pick out the cog's cable_activities, process them,
            # and assign the results to block's bundle_activities
            cog_cable_activities = self.cable_activities[
                self.ziptie.get_index_projection(cog_index).ravel().astype(
                    bool)]
            # Cogs are only allowed to start forming bundles once
            # the number of cables exceeds the fill_fraction_threshold
            enough_cables = (self.ziptie.cable_fraction_in_bundle(cog_index) >
                             self.fill_fraction_threshold)
            cog_bundle_activities = self.cogs[cog_index].step_up(
                cog_cable_activities, enough_cables)
            self.bundle_activities = np.concatenate(
                (self.bundle_activities, cog_bundle_activities))
        # Goal fulfillment and decay
        self.hub_cable_goals -= self.cable_activities
        self.hub_cable_goals *= self.ACTIVITY_DECAY_RATE
        self.hub_cable_goals = np.maximum(self.hub_cable_goals, 0.)
        return self.bundle_activities
Ejemplo n.º 30
0
 def step_up(self, cable_activities):
     """ Train the daisychain using the current cable_activities """
     self.num_cables = np.maximum(self.num_cables, cable_activities.size)
     # Pad the incoming cable_activities array out to its full size
     cable_activities = tools.pad(cable_activities,
                                  (self.max_num_cables, 0))
     # Update cable_activities, incorporating sensing dynamics
     self.pre = self.cable_activities.copy()
     self.cable_activities = cable_activities.copy()
     self.post = self.cable_activities.copy()
     chain_activities = self.pre * self.post.T
     self.count += chain_activities
     self.count -= 1 / (self.AGING_TIME_CONSTANT * self.count +
                        tools.EPSILON)
     self.count = np.maximum(self.count, 0)
     update_rate_raw_post = (self.pre * (
         (1 - self.CHAIN_UPDATE_RATE) /
         (self.pre_count + tools.EPSILON) + self.CHAIN_UPDATE_RATE))
     update_rate_post = np.minimum(0.5, update_rate_raw_post)
     self.pre_count += self.pre
     self.pre_count -= 1 / (self.AGING_TIME_CONSTANT * self.pre_count +
                            tools.EPSILON)
     self.pre_count = np.maximum(self.pre_count, 0)
     post_difference = np.abs(self.pre * self.post.T -
                              self.expected_cable_activities)
     self.expected_cable_activities += update_rate_post * (
         self.pre * self.post.T - self.expected_cable_activities)
     self.post_uncertainty += (post_difference -
                               self.post_uncertainty) * update_rate_post
     # Reaction is the expected post, turned into a deliberation_vote
     self.reaction = tools.weighted_average(self.expected_cable_activities,
                                            self.pre)
     # Surprise is the difference between the expected post and
     # the actual one
     surprise_weights = (self.pre /
                         (self.post_uncertainty + tools.EPSILON) +
                         tools.EPSILON)
     self.surprise = tools.weighted_average(
         np.abs(self.post.T - self.expected_cable_activities),
         surprise_weights)
     # Reshape chain activities into a single column
     return chain_activities.ravel()[:, np.newaxis]
Ejemplo n.º 31
0
    def step_up(self, new_cable_activities):
        """ Find bundle_activities that result from new_cable_activities """
        # Condition the cable activities to fall between 0 and 1
        if new_cable_activities.size < self.max_cables:
            new_cable_activities = tools.pad(new_cable_activities, 
                                             (self.max_cables, 1))
        self.min_vals = np.minimum(new_cable_activities, self.min_vals)
        self.max_vals = np.maximum(new_cable_activities, self.max_vals)
        spread = self.max_vals - self.min_vals
        new_cable_activities = ((new_cable_activities - self.min_vals) / 
                   (self.max_vals - self.min_vals + tools.EPSILON))
        self.min_vals += spread * self.RANGE_DECAY_RATE
        self.max_vals -= spread * self.RANGE_DECAY_RATE
        # Update cable_activities, incorporating sensing dynamics
        self.cable_activities = tools.bounded_sum([
                new_cable_activities, 
                self.cable_activities * (1. - self.ACTIVITY_DECAY_RATE)])

        # Update the map from self.cable_activities to cogs
        self.ziptie.step_up(self.cable_activities)
        # Process the upward pass of each of the cogs in the block
        self.bundle_activities = np.zeros((0, 1))
        for cog_index in range(len(self.cogs)):
            # Pick out the cog's cable_activities, process them, 
            # and assign the results to block's bundle_activities
            cog_cable_activities = self.cable_activities[
                    self.ziptie.get_index_projection(
                    cog_index).ravel().astype(bool)]
            # Cogs are only allowed to start forming bundles once 
            # the number of cables exceeds the fill_fraction_threshold
            enough_cables = (self.ziptie.cable_fraction_in_bundle(cog_index)
                             > self.fill_fraction_threshold)
            cog_bundle_activities = self.cogs[cog_index].step_up(
                    cog_cable_activities, enough_cables)
            self.bundle_activities = np.concatenate((self.bundle_activities, 
                                                     cog_bundle_activities))
        # Goal fulfillment and decay
        self.hub_cable_goals -= self.cable_activities
        self.hub_cable_goals *= self.ACTIVITY_DECAY_RATE
        self.hub_cable_goals = np.maximum(self.hub_cable_goals, 0.)
        return self.bundle_activities
Ejemplo n.º 32
0
 def add_cables(self, num_new_cables):
     """ 
     Add new cables to the hub when new gearboxes are created 
     """ 
     self.num_cables = self.num_cables + num_new_cables
     features_shape = (self.num_cables, 1)
     transition_shape = (self.num_cables, self.num_actions) 
     self.reward = tools.pad(self.reward, transition_shape)
     self.count = tools.pad(self.count, transition_shape)
     self.running_activity = tools.pad(self.running_activity, 
                                           transition_shape)
     self.mask = tools.pad(self.mask, features_shape)
     for index in range(len(self.activity_history)):
         self.activity_history[index] = tools.pad(
                 self.activity_history[index], features_shape)
         self.action_history[index] = tools.pad(
                 self.action_history[index], (self.num_actions, 1))
Ejemplo n.º 33
0
    def step_up(self, new_cable_activities, reward):
        """ Find bundle_activities that result from new_cable_activities """
        new_cable_activities = tools.pad(new_cable_activities, 
                                         (self.max_cables, 1))
        '''
        # Condition the new_cable_activities to fall between 0 and 1
        self.min_vals = np.minimum(new_cable_activities, self.min_vals)
        self.max_vals = np.maximum(new_cable_activities, self.max_vals)
        spread = self.max_vals - self.min_vals
        new_cable_activities = ((new_cable_activities - self.min_vals) / 
                            (self.max_vals - self.min_vals + tools.EPSILON))
        self.min_vals += spread * self.RANGE_DECAY_RATE
        self.max_vals -= spread * self.RANGE_DECAY_RATE
        '''
        # Update cable_activities, incorporating sensing dynamics
        self.cable_activities = tools.bounded_sum([
                new_cable_activities, 
                self.cable_activities * (1. - self.ACTIVITY_DECAY_RATE)])
        # debug 
        #print self.name, 'ca', self.cable_activities.shape
        #print self.cable_activities.ravel()

        # Update the map from self.cable_activities to cogs
        self.ziptie.update(self.cable_activities)
        # Process the upward pass of each of the cogs in the block
        self.bundle_activities = np.zeros((0, 1))
        for cog_index in range(len(self.cogs)):
            # Pick out the cog's cable_activities, process them, 
            # and assign the results to block's bundle_activities
            cog_cable_activities = self.cable_activities[
                    self.ziptie.get_projection(cog_index).ravel().astype(bool)]
            enough_cables = (self.ziptie.cable_fraction_in_bundle(cog_index)
                             > 0.7)
            cog_bundle_activities = self.cogs[cog_index].step_up(
                    cog_cable_activities, reward, enough_cables)
            self.bundle_activities = np.concatenate((self.bundle_activities, 
                                                     cog_bundle_activities))
        return self.bundle_activities
Ejemplo n.º 34
0
 def step_up(self, cable_activities, enough_cables):
     """ 
     Cable_activities percolate upward through daisychain and ziptie 
     """
     # TODO: fix this so that cogs can gracefully handle more cables 
     # or else never be assigned them in the first place. 
     # Enable them to grow dynamically, rather than preallocated,
     # if that can be shown to improve performance.
     if cable_activities.size > self.max_cables:
         cable_activities = cable_activities[:self.max_cables, :]
         print ''.join(['-----  Number of max cables exceeded in', 
                         self.name, '  -----'])
     chain_activities = self.daisychain.step_up(cable_activities)
     # Wait to start training the cog's bundles until the cog's
     # input cables are adequately populated. This is the job
     # of the gearbox's ziptie.
     if enough_cables is True:
         bundle_activities = self.ziptie.step_up(chain_activities)
     else:
         bundle_activities = np.zeros((0,1))
     # TODO: Check whether this is necessary
     bundle_activities = tools.pad(bundle_activities, (self.max_bundles, 0))
     return bundle_activities
Ejemplo n.º 35
0
from Crypto.Cipher import AES
from tools import create_parser, join, pad
from base64 import b64encode

if __name__ == '__main__':
    parser = create_parser()
    namespace = parser.parse_args()

    key = namespace.password.encode()
    key = pad(key, AES.block_size)

    cipher = AES.new(key, AES.MODE_CBC)

    try:
        # try to open file with passwords
        file = open(namespace.sourcefile, 'r')
    except FileNotFoundError:
        # if file dose note found, close the program
        print('Source file not found')
        raise SystemExit(1)

    passwords = file.read().encode()
    file.close()

    encrypted_bytes = cipher.encrypt(pad(passwords, AES.block_size))

    path = namespace.encryptedfile
    name = namespace.name

    iv = b64encode(cipher.iv).decode('utf-8')
    encrypted = b64encode(encrypted_bytes).decode('utf-8')
Ejemplo n.º 36
0
import numpy as np
import tools as tl
import time

bl_size = 32
src = 'source/park.png'
dst = 'fig'
processor = 'gpu'

start = time.time()
img = tl.read_file(src)
img = tl.pad(img, bl_size)
shape = np.shape(img)
block = tl.break_block(img, bl_size)
predict, mode_predict = tl.inpainting(block, bl_size, processor = processor)
time_total = time.time() - start
print 'predict size:	', np.shape(predict)
print 'block size:	', np.shape(predict[0])
print 'max:	', np.max(predict)
print 'min:	', np.min(predict)
print time_total
predict = tl.group_block(predict, bl_size, shape)
#predict = np.uint8(predict * (255.0 / np.max(predict)))
#predict = np.uint8(predict)
#plt.imshow(predict, cmap = cm.Greys_r)

np.save(dst, predict)

print 'Done'

Ejemplo n.º 37
0
import numpy as np
import tools as tl
import time

bl_size = 8
src = 'source/park.png'
dst = 'fig'
processor = 'gpu'

start = time.time()
img = tl.read_file(src)
img = tl.pad(img, bl_size)
shape = np.shape(img)
block = tl.break_block(img, bl_size)
predict, mode_predict = tl.inpainting(block, bl_size, processor=processor)
time_total = time.time() - start
print 'predict size:	', np.shape(predict)
print 'block size:	', np.shape(predict[0])
print 'max:	', np.max(predict)
print 'min:	', np.min(predict)
print time_total
predict = tl.group_block(predict, bl_size, shape)
#predict = np.uint8(predict * (255.0 / np.max(predict)))
#predict = np.uint8(predict)
#plt.imshow(predict, cmap = cm.Greys_r)

np.save(dst, predict)

print 'Done'
Ejemplo n.º 38
0
 def add_cables(self, num_new_cables):
     """ Add new cables to the hub when new gearboxes are created """ 
     self.num_cables = self.num_cables + num_new_cables
     transition_shape = (self.num_cables, self.num_cables)
     self.value = tools.pad(self.value, transition_shape)
     self.reward = tools.pad(self.reward, transition_shape)
Ejemplo n.º 39
0
 def add_cables(self, num_new_cables):
     """ Add new cables to the hub when new gearboxes are created """ 
     self.num_cables += num_new_cables
     features_shape = (self.num_cables, 1)
     self.time_since_seen = tools.pad(self.time_since_seen, features_shape,
                             val=self.INITIAL_TIME)
Ejemplo n.º 40
0
os.environ["CUDA_VISIBLE_DEVICES"] = "3"
'''
Max English sentence: 642
Max Spanish sentence: 632
'''
max_spanish_sequence_length = 632
max_english_sequence_lengh = 642

en_tokenized = load_clean_sentences(
    "/home/8id/scriptTesting/translateData/english_tokenized")
sp_tokenized = load_clean_sentences(
    "/home/8id/scriptTesting/translateData/spanish_tokenized")
sp_tokenizer = loadTokenizer("/home/8id/scriptTesting/translateData/sp")
en_tokenizer = loadTokenizer("/home/8id/scriptTesting/translateData/en")

en_tokenized_padded = pad(en_tokenized, 642)
sp_tokenized_padded = pad(sp_tokenized, 632)
sp_tokenized_padded = sp_tokenized_padded.reshape((-1, 632, 1))

spanish_vocab_size = len(sp_tokenizer.word_index)
english_vocab_size = len(en_tokenizer.word_index)
print("English vocabulary size:", english_vocab_size)
print("Spanish vocabulary size:", spanish_vocab_size)
print("----")
print(sp_tokenized_padded.shape)
print(en_tokenized_padded.shape)
print("read This:::::::", sp_tokenized_padded.shape[-2])
# Reshaping the input to work with a basic RNN
tmp_x = pad(en_tokenized_padded, 632)
tmp_x = tmp_x.reshape((-1, sp_tokenized_padded.shape[-2], 1))
Ejemplo n.º 41
0
    def step_up(self, new_cable_activities):
        """ 
        Update co-activity estimates and calculate bundle activity 
        """
        if new_cable_activities.size < self.max_num_cables:
            new_cable_activities = tools.pad(new_cable_activities, 
                                             (self.max_num_cables, 1))
        # debug: don't adapt cable activities 
        self.cable_activities = new_cable_activities
        self.cable_activities = tools.bounded_sum2(new_cable_activities, 
                self.cable_activities * (1. - self.ACTIVITY_DECAY_RATE))
        '''
        """
        Find bundle activities by taking the generalized mean of
        the signals with a negative exponent.
        The negative exponent weights the lower signals more heavily.
        Make a first pass at the bundle activation levels by 
        multiplying across the bundle map.
        """
        initial_bundle_activities = tools.generalized_mean(
                self.cable_activities, self.bundle_map.T, self.MEAN_EXPONENT)

        bundle_contribution_map = np.zeros(self.bundle_map.shape)
        bundle_contribution_map[np.nonzero(self.bundle_map)] = 1.
        # Use aggressive lateral inhibition between bundles so that 
        # cables' activity is monopolized by the strongest-activated bundle.
        activated_bundle_map = (initial_bundle_activities * 
                                bundle_contribution_map)
        # Add just a little noise to break ties
        activated_bundle_map += 1e-4 * np.random.random_sample(
                activated_bundle_map.shape)
        # Find the largest bundle activity that each input contributes to
        max_activation = (np.max(activated_bundle_map, axis=0) + 
                          tools.EPSILON)
        # Divide the energy that each input contributes to each bundle
        input_inhibition_map = np.power(activated_bundle_map / max_activation, 
                                        self.ACTIVATION_WEIGHTING_EXPONENT)
        # Find the effective strength of each cable to each bundle 
        # after inhibition.
        inhibited_cable_activities = (input_inhibition_map * 
                                      self.cable_activities.T)
        final_bundle_activities = tools.generalized_mean(
                inhibited_cable_activities.T, self.bundle_map.T, 
                self.MEAN_EXPONENT)
        self.bundle_activities = final_bundle_activities
        '''
        """
        Find bundle activities by taking the minimum input value
        in the set of cables in the bundle.
        """
        #self.bundle_map[np.where(self.bundle_map==0.)] = np.nan
        bundle_components = self.bundle_map * self.cable_activities.T 
        # TODO: consider other ways to calculate bundle energies
        self.bundle_energies = np.nansum(bundle_components,
                                         axis=1)[:,np.newaxis]
        self.bundle_energies[np.where(np.isnan(self.bundle_energies))] = 0.
        #print 'be', self.bundle_energies.T
        energy_index = np.argsort(self.bundle_energies.ravel())[:,np.newaxis]
        #print 'ei', energy_index.T
        max_energy = self.bundle_energies[energy_index[-1]]
        #print 'max_e', max_energy
        mod_energies = self.bundle_energies - (
                max_energy * ( (self.num_bundles - energy_index) / 
                               (self.num_bundles + tools.EPSILON) ))
        #print 'me', mod_energies.T
        
        self.bundle_activities = np.nanmin(bundle_components,
                                           axis=1)[:,np.newaxis]
        #print 'ba before', self.bundle_activities.T
        self.bundle_activities[np.where(mod_energies < 0.)] = 0.
        self.bundle_activities = np.nan_to_num(self.bundle_activities)
        #self.bundle_activities[np.where(np.isnan(self.bundle_activities))] = 0.
        #print 'ba', self.bundle_activities.T

        self.reconstruction = np.nanmax(self.bundle_activities * 
                                        self.bundle_map, 
                                        axis=0)[:, np.newaxis]
        self.reconstruction[np.isnan(self.reconstruction)] = 0.
        self.nonbundle_activities = self.cable_activities - self.reconstruction
        #print 'recon', self.reconstruction.T
        #print 'nba', self.nonbundle_activities.T
        '''
        # Calculate how much energy each input has left to contribute 
        # to the co-activity estimate. 
        final_activated_bundle_map = (final_bundle_activities * 
                                      bundle_contribution_map)
        combined_weights = np.sum(final_activated_bundle_map, 
                                  axis=0)[:,np.newaxis]
        '''
        '''
        if self.in_gearbox:
            self.nonbundle_activities = (cable_activities * 
                    2 ** -np.sum(self.bundle_map, axis=0)[:,np.newaxis])
        else:
            self.nonbundle_activities = np.maximum(0., cable_activities - 
                                                   combined_weights)
        self.nonbundle_activities = np.maximum(0., self.cable_activities - 
                                               combined_weights)
        #self.cable_activities = cable_activities
        '''
        # As appropriate update the co-activity estimate and 
        # create new bundles
        if not self.exploit:
            if not self.bundles_full:
                self._create_new_bundles()
            self._grow_bundles()
        return self.bundle_activities
Ejemplo n.º 42
0
from base64 import b64decode

if __name__ == '__main__':
    parser: ArgumentParser = create_parser()
    namespace = parser.parse_args()

    try:
        file = open(namespace.encryptedfile, 'r')
    except:
        print('Encrypted file path error')
        raise SystemExit(1)
    crypto: str = file.read()
    file.close()

    key: bytes = namespace.password.encode()
    key = pad(key, AES.block_size)

    iv = b64decode(crypto[0:24])
    ct = b64decode(crypto[24:])

    cipher: AES = AES.new(key, AES.MODE_CBC, iv)
    try:
        data: bytes = unpad(cipher.decrypt(ct), AES.block_size)
    except ValueError:
        print("Error password")
        raise SystemExit(1)

    try:
        passwords = data.decode()

    except UnicodeDecodeError: