def design_thetas(nodes): return_obj = { 'L': 0, 'dimensions': [], 'thetas': [], # 'empty_DIJ' : [] } r6 = sqrt(6) # initializing empty theta and DIJ thetas = [np.array([0])] # empty_DIJ = [np.array([0])] # dimensions for the theta(l) matrices dimen_mat = [[y, x + 1] for x, y in zip(nodes, nodes[1:])] return_obj['dimensions'] = dimen_mat return_obj['L'] = len(dimen_mat) for i in dimen_mat: epsilon = r6 / sqrt(i[0] + (i[-1] - 1)) thetas.append(-epsilon + (2 * epsilon) * np.random.rand(i[0], i[-1])) # empty_DIJ.append(np.zeros((i[0], i[-1]))) return_obj['thetas'] = thetas # return_obj['empty_DIJ'] = empty_DIJ return helper.unpack(return_obj)
def parse(buff): mh = MinidumpHeader() mh.Signature = buff.read(4).decode()[::-1] if mh.Signature != 'PMDM': raise MinidumpHeaderSignatureMismatchException(mh.Signature) mh.Version = unpack(buff.read(4)) mh.NumberOfStreams = unpack(buff.read(4)) mh.StreamDirectoryRva = unpack(buff.read(4)) mh.CheckSum = unpack(buff.read(4)) mh.TimeDateStamp = unpack(buff.read(4)) try: mh.Flags = unpack(buff.read(8)) except Exception as e: raise MinidumpHeaderFlagsException('Could not parse header flags!') return mh
def parse(buff): ms = MINIDUMP_STRING() ms.Length = unpack(buff.read(4)) ms.Buffer = buff.read(ms.Length) return ms
def parse(buff): mld = MINIDUMP_LOCATION_DESCRIPTOR64() mld.DataSize = unpack(buff.read(8)) mld.Rva = unpack(buff.read(8)) return mld
def parse(buff): md = MINIDUMP_DIRECTORY() md.StreamType = unpack(buff.read(4)) md.Location = MINIDUMP_LOCATION_DESCRIPTOR.parse(buff) return md
import socket import struct import binascii import os import helper i = 0 s=socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0800)) print '[*] packet get' while True: pkt=s.recvfrom(65565) unpack=helper.unpack() print "\nEthernet Header" for i in unpack.eth_h(pkt[0][0:14]).iteritems(): a,b=i print "{} : {}\n".format(a,b), print "\nIP Header" for i in unpack.ip_h(pkt[0][14:34]).iteritems(): a,b=i print "{} : {}\n".format(a,b), print "\nTcp Header" for i in unpack.tcp_h(pkt[0][34:54]).iteritems(): a,b=i print "{} : {}\n".format(a,b),
def __init__(self, reader): self.value = unpack(reader.read(4))
def calc_gradient(thetas, raw_data, lambd=0): return_obj = {'Dij': [], 'cost': 0, 'lambda': lambd} # copying the dataset to prevent change # initalizing useful params dataset = raw_data Dij = [] is_empty = True cost = 0 m = len(dataset) # iterating over the dataset, # performing FP and BP for i in dataset: # these layers are used to prevent redundant calc for BP activation_layers = [[]] # inital layer taken from the dataset initial_layer = np.matrix([1] + i[0]) yi = np.matrix(i[-1]).T # expected output # inital activation value set to input data current_activation = initial_layer.T # adding inital activation a(1) -> input activation_layers.append(current_activation) # iterating over the layers performing FP for theta_L in thetas[1:]: # creating raw non-activated current_raw = theta_L.dot(current_activation) # sigmoiding the previous output prior to adding one current_activated = sigmoid(current_raw) # adding bias unit next_layer = np.r_[[[1]], current_activated] activation_layers.append(next_layer) # for the next iteration after adding bias unit current_activation = next_layer # removing final layer bias unit activation_layers[-1] = activation_layers[-1][1:, :] # error associated with the output delta_L = activation_layers[-1] - yi # these deltas are required every iteration delta_layers = [delta_L] # setting delta for current iteration previous_delta = delta_L # L required for certain index calc. L = len(activation_layers) - 1 # accumilating the cost cost cost += (np.multiply(yi, np.log(activation_layers[-1])) + \ np.multiply((1 - yi), np.log(1 - activation_layers[-1]))) # performing backpropogation for idx, l in enumerate(activation_layers[-2:1:-1]): # calculating current layer delta current_delta = ((thetas[L - (idx + 1)][:, 1:]).T).dot(previous_delta) active_factor = np.multiply(l[1:, :], (1 - l[1:, :])) current_delta = np.multiply(current_delta, active_factor) # print("D%d" % (L - (idx + 1)), current_delta) # adding the delta layer to the legend delta_layers.append(current_delta) # continuing for next iteration previous_delta = current_delta # accumilating calculated delta for all layers # setting up the activation layers activation_layers = activation_layers[ 1:-1] # removing final activation layer activation_layers = activation_layers[:: -1] #reversing list to have a(L - 1) a(L - 2) ... a1 # deltas will be delta(L) delta(L - 1) ... D2 # partial derivative calculated for the current training example current_Dij = [del_current_plus_one * np.matrix(active_current).T \ for del_current_plus_one, active_current in zip(delta_layers, activation_layers)] # accumilating the partial derivative over the training examples Dij = [a + b for a, b in zip(Dij, current_Dij)] # initializes the Dij matrix with the first calculated cost if empty if is_empty: Dij = current_Dij is_empty = False # adding regularization and averaging partials Dij = [(1 / m) * x for x in Dij][::-1] cost = (-1 / m) * cost[0, 0] if lambd: # regularizing cost cost # summing the thetas .^ 2 except theta_0 regular_cost = (lambd / (2 * m)) * sum( [np.sum(np.multiply(y[:, 1:], y[:, 1:])) for y in thetas[1:]]) cost += regular_cost # regularizing the partial derivatives except D0 regular_factor = (lambd / m) regular_matrix = [ np.matrix([[regular_factor * x if j else 0 for j, x in enumerate(row)] \ for row in mat]) for mat in thetas[1:] ] Dij = [a + b for a, b in zip(Dij, regular_matrix)] # print("R", regular_matrix, "d", Dij, "t", thetas, sep = "\n") return_obj['cost'] = cost return_obj['Dij'] = Dij return helper.unpack(return_obj)