def information(activation): data_t = activation if bins == -1: data_t = [ bin_array(t, bins=30, low=t.min(), high=t.max()) for t in data_t ] else: data_t = [ bin_array(t, bins=bins, low=t.min(), high=t.max()) for t in data_t ] #data_t = [binarize(t) for t in data_t] data_t = [hash_data(t) for t in data_t] h_t = np.array([entropy_of_data(t) for t in data_t]) #h_t_x = np.array([__conditional_entropy(t, data_x) for t in data_t]) h_t_y = np.array([__conditional_entropy(t, data_y) for t in data_t]) h_t_t = np.array( [__conditional_entropy(t1, t2) for (t1, t2) in pairwise(data_t)]) i_x_t = h_t # - h_t_x # H(T, X) is 0 since every element in X is unique i_y_t = h_t - h_t_y i_t_t = h_t[:-1] - h_t_t return i_x_t, i_y_t, i_t_t
def join(strhash=None): key = hash_data(gen_rand_ip()) print("Join with index %s" % key) if not len(nodes): node = Node(key) node.predecessor = node node.setsuccessor(node) nodes.append(node) else: # root = find(strhash) root = rootnode().predecessor print("Root node %s" % root) successor = root.finger[0] while root != successor and key < successor.node_id: print("%s < %s" % (key, successor.node_id)) successor = successor.finger[0] successor = successor.predecessor print("Set %s as predecessor of %s" % (key, successor.node_id)) newnode = Node(key) newnode.setsuccessor(successor) if successor.predecessor is not None: newnode.predecessor = successor.predecessor successor.predecessor.setsuccessor(newnode) successor.predecessor = newnode else: # addition of second node in network newnode.predecessor = successor successor.predecessor = newnode successor.setsuccessor(newnode) nodes.append(newnode)
def hears(): """ This route listens for incoming events from Slack and uses the event handler helper function to route events to our Bot. """ slack_event = json.loads(request.data) # ============= Slack URL Verification ============ # if "challenge" in slack_event: return make_response(slack_event["challenge"], 200, {"content_type": "application/json"}) # ============ Slack Token Verification =========== # if pyBot.verification != slack_event.get("token"): message = f"Invalid Slack verification token: {slack_event['token']}\npyBot has: {pyBot.verification}\n\n" # By adding "X-Slack-No-Retry" : 1 to our response headers, we turn off Slack's automatic retries during # development. return make_response(message, 403, {"X-Slack-No-Retry": 1}) # ====== Prevent Duplicate Processing ====== # _, created = get_or_create_event_log(hash_data(slack_event)) if not created: return make_response("Got it.", 200, {"content_type": "application/json"}) # ====== Process Incoming Events from Slack ======= # if "event" in slack_event: event_type = slack_event["event"]["type"] # Then handle the event by event_type and have your bot respond return _event_handler(event_type, slack_event) return make_response("[NO EVENT IN SLACK REQUEST] These are not the droids you're looking for.", 404, {"X-Slack-No-Retry": 1})
def finddata(strhash, key): # still linear root = find(strhash) successor = find(strhash).finger[0] hashkey = hash_data(key) while root != successor and hashkey < successor.node_id: successor = successor.finger[0] print("searching in %s" % successor.node_id) return successor.find_data(key)
def insert(strhash, key, data): hashkey = hash_data(key) print("Hashed key %s" % hashkey) root = find(strhash) successor = find(strhash).finger[0] while root != successor and hashkey < successor.node_id: successor = successor.finger[0] successor.insert_data(key, data)
def calculate_information_tishby(input_values, labels, bins=30): # activation layers*test_case*neuron -> value) # calculate information I(X,T) and I(T,Y) where X is the input and Y is the output # and T is any layer data_x = hash_data(input_values) data_y = hash_data(labels) #data_x = binarize(input_values) #data_y = binarize(labels) def information(activation): data_t = activation if bins == -1: data_t = [ bin_array(t, bins=30, low=t.min(), high=t.max()) for t in data_t ] else: data_t = [ bin_array(t, bins=bins, low=t.min(), high=t.max()) for t in data_t ] #data_t = [binarize(t) for t in data_t] data_t = [hash_data(t) for t in data_t] h_t = np.array([entropy_of_data(t) for t in data_t]) #h_t_x = np.array([__conditional_entropy(t, data_x) for t in data_t]) h_t_y = np.array([__conditional_entropy(t, data_y) for t in data_t]) h_t_t = np.array( [__conditional_entropy(t1, t2) for (t1, t2) in pairwise(data_t)]) i_x_t = h_t # - h_t_x # H(T, X) is 0 since every element in X is unique i_y_t = h_t - h_t_y i_t_t = h_t[:-1] - h_t_t return i_x_t, i_y_t, i_t_t return information
def data(self): """Ensure data is in the form of a HashLeaf data structures and has the correct height. Separate method from `HashLeaf` as there are different requirements """ # assert isinstance(self._left, MerkleLeaf), "Data is not of type `MerkleLeaf`" # assert isinstance(self._right, MerkleLeaf), "Data is not of type `MerkleLeaf`" assert self._left.height == self._right.height, "Left and right branch not balanced" return hash_data(self._left.data + self._right.data)
def compute_single(saved, dist): x_test_hash = hash_data(x_test) data_x = x_test_hash for _ in range(dist - 1): data_x = np.concatenate((data_x, x_test_hash)) y_test_hash = hash_data(y_test) data_y = y_test_hash for _ in range(dist - 1): data_y = np.concatenate((data_y, y_test_hash)) # saved data where every number is binned saved_bin = [[ bin_array(layer, bins=args.bins, low=layer.min(), high=layer.max()) for layer in epoch ] for epoch in saved] # saved data where every number is hashed saved_hash = [[hash_data(layer) for layer in epoch] for epoch in saved_bin] data_t = {} for t in range(len(saved_hash[0])): data_t[t] = np.array([], dtype=np.int64) for epoch in range(len(saved_hash)): for t in range(len(saved_hash[0])): data_t[t] = np.concatenate([data_t[t], saved_hash[epoch][t]]) data_t = list(data_t.values()) h_t = np.array([entropy_of_data(t) for t in data_t]) h_t_x = np.array([__conditional_entropy(t, data_x) for t in data_t]) h_t_y = np.array([__conditional_entropy(t, data_y) for t in data_t]) i_x_t = h_t - h_t_x i_y_t = h_t - h_t_y return i_x_t, i_y_t
def _event_handler(event_type, slack_event): """ A helper function that routes events from Slack to our Bot by event type and subtype. Parameters ---------- event_type : str type of event recieved from Slack slack_event : dict JSON response from a Slack reaction event Returns ---------- obj Response object with 200 - ok or 500 - No Event Handler error """ # ============= Reaction Added Events ============= # # If the user has added an emoji reaction to one message if event_type == "reaction_added": user_id = slack_event["event"]["user"] # Some messages aren't authored by "users," like those created by incoming webhooks. # reaction_added events related to these messages will not include an item_user. item_user_id = slack_event["event"].get("item_user") reaction = slack_event["event"]["reaction"] # only log others' poultry_leg reaction to a real user if item_user_id and reaction == 'poultry_leg' and (CONFIG.DEBUG or item_user_id != user_id): message = json.dumps(slack_event["event"]["item"], separators=(',', ':')) print(f'{user_id} ({reaction}) > {item_user_id} @({message})') create_user_message_reaction_log(to_user_id=item_user_id, from_user_id=user_id, message_hash=hash_data(slack_event["event"]["item"]), reaction=reaction) # pyBot.notify_being_added_poultry_leg(user_id=user_id, item_user_id=item_user_id) return make_response("reaction logged", 200, ) # If the user has mentioned the app elif event_type == "app_mention": # text = slack_event["event"]["text"] channel = slack_event["event"]["channel"] pyBot.tell_leaderboard(channel) return make_response("reaction logged", 200, ) # ============= Event Type Not Found! ============= # # If the event_type does not have a handler message = "You have not added an event handler for the %s" % event_type # Return a helpful error message return make_response(message, 200, {"X-Slack-No-Retry": 1})
def data(self): """str: Allow the user to query the hashed data stored in the MerkleLeaf """ return hash_data(self._left.encode() + self._right.encode())