def __init__(self): total_data = 2**8 for i in range(total_data): binary_number = to_binary(i) binary_number = extend_to_bits(to_binary(i)) random_number = to_binaryC2(random.randint(-(2**31), (2**31) - 1)) self.data[binary_number] = random_number
def __init__(self): total_registers = 2**5 for i in range(total_registers): binary_number = to_binary(i) if len(binary_number) < 5: zero_fill = 5 - len(binary_number) binary_number = "{}{}".format("0" * zero_fill, binary_number) if i == 8: self.data[binary_number] = extend_to_bits(to_binary(16)) else: self.data[binary_number] = False
def test(): p = creds._pub[1] print(p) msg = utils.point_to_string(p) print(msg) msg = utils.to_binary(msg) enc = creds.encrypt(msg) enc = utils.to_binary(enc) enc = bytes.decode(enc) msg = creds.decrypt(enc) print(msg) p = utils.string_to_point(msg) print(p)
def excess(integer): integer += 127 number = to_binary(integer)[::-1] while len(number) < 8: number = "0" + number return number
def makeOr(self, a, b): a = int(a, 2) b = int(b, 2) result = to_binary((a | b)) return extend_to_bits(result)
def load_sequens_data(fname_seq): seq_dict = {'id': [], 'prop': [], 'seq': [], 'seq_bin': []} for rec in SeqIO.parse(fname_seq, 'fasta'): seq_dict['id'].append(rec.id) seq_dict['prop'].append(float(rec.description.split()[-1])) seq_dict['seq'].append(rec.seq) seq_dict['seq_bin'].append(to_binary(rec.seq)) return seq_dict
def to_signed_binary(integer, sign): number = to_binary(integer) if len(number) >= 8: number = number[:8] return number[::-1] while len(number) < 7: number += '0' return sign + number[::-1]
def run(): """ Solution: Pretty straightforward search. """ N = 1000000 total = 0 for n in xrange(1, N): if not is_palindrome(n): continue if is_palindrome(to_binary(n)): total += n return total
def __init__(self, dataset, data_dir, list_IDs, batch_size=1, dim=(32,32,32), shuffle=True, transform=None, verbose=0, prows=None): 'Initialization' self.dim = dim self.batch_size = batch_size self.list_IDs = list_IDs self.shuffle = shuffle self.on_epoch_end() self.data = dataset self.transform = transform self.verbose = verbose self.X_gene = to_binary(self.data) self.X_chem = smiles_to_onehot(self.data) self.Y = self.data['LN_IC50'].tolist()
def classify_rnn1(model, text: List[str]) -> str: word2index = joblib.load('./word2index') tag2index = joblib.load('./tag2index') t = preprocessing(text) new_sent = [word2index[word] for word in t] max_len = 5423 x = pad_sequences(truncating='post', maxlen=max_len, sequences=[new_sent], padding='post', value=0) cats = model.predict(x) pred = to_binary(cats) pred2 = to_tags(pred, tag2index) return pred2
def next_ip(broadcast): tinit = "" for x in broadcast: tinit = tinit + x tdec = to_decimal(int(tinit)) tbin = binary_fixed(to_binary(tdec + 1), 32) tinit = "" tmp = "" for i in range(0, len(tbin)): if (i % 8) == 0 and i != 0: tinit = tinit + str(to_decimal(int(tmp))) + "." tmp = "" tmp = tmp + tbin[i] tinit = tinit + str(to_decimal(int(tmp))) return tinit
def align(img): """ Aligns text present in input image, by calculating 2d rectangle encapsulating it. Note that the input should be binary image! """ coords = np.column_stack(np.where(img > 0)) neg_angle = cv2.minAreaRect(coords)[-1] angle = -neg_angle if angle > 45: angle -= 90 h, w = img.shape rot_matrix = cv2.getRotationMatrix2D((w // 2, h // 2), angle, 1.0) rotated = cv2.warpAffine(img, rot_matrix, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE, borderValue=0) rotated = utils.to_binary(rotated) return rotated
] if race: race_list = list(set(x['race'])) columns += [(x['race'] == n) for n in race_list] cnames += ['Race=%s' % r for r in race_list] columns.append(x['two_year_recid']) cnames.append('recidivate-within-two-years') print 'write categorical dataset', fout y = tb.tabarray(columns=columns, names=cnames) y.saveSV(fout) print 'write binary dataset', bout b = utils.to_binary(y) b.saveSV(bout) print 'permute and partition dataset' split_ind = np.array_split(np.random.permutation(len(y)), num_folds) print 'number of folds:', num_folds print 'train size:', [ sum([len(split_ind[i]) for i in range(num_folds) if i != j]) for j in range(num_folds) ] print 'test size:', [ sum([len(split_ind[i]) for i in range(num_folds) if i == j]) for j in range(num_folds) ] num_rules = np.zeros(num_folds, int)
def train(self, args): # Data from domain A and B, and mixed dataset for partial and full models. dataA = glob("./{}/train/*.*".format(self.dataset_A_dir)) dataB = glob("./{}/train/*.*".format(self.dataset_B_dir)) if args.continue_train: if self.checkpoint.restore(self.checkpoint_manager.latest_checkpoint): print(" [*] Load checkpoint succeeded!") else: print(" [!] Load checkpoint failed.") counter = 1 start_time = time.time() d_loss_list = [] g_loss_list = [] cycle_loss_list = [] print("Training start...") for epoch in range(args.epoch): # Shuffle training data np.random.shuffle(dataA) np.random.shuffle(dataB) # Get the proper number of batches batch_idxs = min(len(dataA), len(dataB)) // self.batch_size # learning rate starts to decay when reaching the threshold self.lr = ( self.lr if epoch < args.epoch_step else self.lr * (args.epoch - epoch) / (args.epoch - args.epoch_step) ) for idx in range(batch_idxs): # To feed real_data batch_files = list( zip( dataA[idx * self.batch_size : (idx + 1) * self.batch_size], dataB[idx * self.batch_size : (idx + 1) * self.batch_size], ) ) batch_samples = [ load_npy_data(batch_file) for batch_file in batch_files ] batch_samples = np.array(batch_samples).astype( np.float32 ) # batch_size * 64 * 84 * 2 real_A, real_B = batch_samples[:, :, :, 0], batch_samples[:, :, :, 1] real_A = tf.expand_dims(real_A, -1) real_B = tf.expand_dims(real_B, -1) # generate gaussian noise for robustness improvement gaussian_noise = np.abs( np.random.normal( 0, self.sigma_d, [ self.batch_size, self.time_step, self.pitch_range, self.input_c_dim, ], ) ).astype(np.float32) with tf.GradientTape(persistent=True) as gen_tape, tf.GradientTape( persistent=True ) as disc_tape: fake_B = self.generator_A2B(real_A, training=True) cycle_A = self.generator_B2A(fake_B, training=True) fake_A = self.generator_B2A(real_B, training=True) cycle_B = self.generator_A2B(fake_A, training=True) [fake_A_sample, fake_B_sample] = self.pool([fake_A, fake_B]) DA_real = self.discriminator_A( real_A + gaussian_noise, training=True ) DB_real = self.discriminator_B( real_B + gaussian_noise, training=True ) DA_fake = self.discriminator_A( fake_A + gaussian_noise, training=True ) DB_fake = self.discriminator_B( fake_B + gaussian_noise, training=True ) DA_fake_sample = self.discriminator_A( fake_A_sample + gaussian_noise, training=True ) DB_fake_sample = self.discriminator_B( fake_B_sample + gaussian_noise, training=True ) # Generator loss cycle_loss = self.L1_lambda * ( abs_criterion(real_A, cycle_A) + abs_criterion(real_B, cycle_B) ) g_A2B_loss = ( self.criterionGAN(DB_fake, tf.ones_like(DB_fake)) + cycle_loss ) g_B2A_loss = ( self.criterionGAN(DA_fake, tf.ones_like(DA_fake)) + cycle_loss ) g_loss = g_A2B_loss + g_B2A_loss - cycle_loss # Discriminator loss d_A_loss_real = self.criterionGAN(DA_real, tf.ones_like(DA_real)) d_A_loss_fake = self.criterionGAN( DA_fake_sample, tf.zeros_like(DA_fake_sample) ) d_A_loss = (d_A_loss_real + d_A_loss_fake) / 2 d_B_loss_real = self.criterionGAN(DB_real, tf.ones_like(DB_real)) d_B_loss_fake = self.criterionGAN( DB_fake_sample, tf.zeros_like(DB_fake_sample) ) d_B_loss = (d_B_loss_real + d_B_loss_fake) / 2 d_loss = d_A_loss + d_B_loss # Calculate the gradients for generator and discriminator generator_A2B_gradients = gen_tape.gradient( target=g_A2B_loss, sources=self.generator_A2B.trainable_variables, ) generator_B2A_gradients = gen_tape.gradient( target=g_B2A_loss, sources=self.generator_B2A.trainable_variables, ) discriminator_A_gradients = disc_tape.gradient( target=d_A_loss, sources=self.discriminator_A.trainable_variables, ) discriminator_B_gradients = disc_tape.gradient( target=d_B_loss, sources=self.discriminator_B.trainable_variables, ) # Apply the gradients to the optimizer self.GA2B_optimizer.apply_gradients( zip( generator_A2B_gradients, self.generator_A2B.trainable_variables, ) ) self.GB2A_optimizer.apply_gradients( zip( generator_B2A_gradients, self.generator_B2A.trainable_variables, ) ) self.DA_optimizer.apply_gradients( zip( discriminator_A_gradients, self.discriminator_A.trainable_variables, ) ) self.DB_optimizer.apply_gradients( zip( discriminator_B_gradients, self.discriminator_B.trainable_variables, ) ) print( "=================================================================" ) print( ( "Epoch: [%2d] [%4d/%4d] time: %4.4f D_loss: %6.2f, G_loss: %6.2f, cycle_loss: %6.2f" % ( epoch, idx, batch_idxs, time.time() - start_time, d_loss, g_loss, cycle_loss, ) ) ) # ADDED d_loss_list.append(d_loss) g_loss_list.append(g_loss) cycle_loss_list.append(cycle_loss) counter += 1 # generate samples during training to track the learning process if np.mod(counter, args.print_freq) == 1: sample_dir = os.path.join( self.sample_dir, "{}2{}_{}_{}_{}".format( self.dataset_A_dir, self.dataset_B_dir, self.now_datetime, self.model, self.sigma_d, ), ) if not os.path.exists(sample_dir): os.makedirs(sample_dir) # to binary, 0 denotes note off, 1 denotes note on samples = [ to_binary(real_A, 0.5), to_binary(fake_B, 0.5), to_binary(cycle_A, 0.5), to_binary(real_B, 0.5), to_binary(fake_A, 0.5), to_binary(cycle_B, 0.5), ] self.sample_model( samples=samples, sample_dir=sample_dir, epoch=epoch, idx=idx ) if np.mod(counter, args.save_freq) == 1: self.checkpoint_manager.save(counter) pickle_loss_list(d_loss_list, self.d_loss_path) pickle_loss_list(g_loss_list, self.g_loss_path) pickle_loss_list(cycle_loss_list, self.cycle_loss_path)
random.shuffle(AI2) random.shuffle(COMMONCORE) random.shuffle(ILLINOIS) random.shuffle(MAWPS) random.shuffle(GENERATED) # AI2 testing data test_pre_ai2 = convert_to(AI2_TEST, "prefix") test_pos_ai2 = convert_to(AI2_TEST, "postfix") if KEEP_INFIX_PARENTHESIS: test_inf_ai2 = remove_variables(AI2_TEST) test_inf_ai2 = test_inf_ai2[:len(test_pos_ai2)] else: test_inf_ai2 = convert_to(AI2_TEST, "infix") to_binary(os.path.join(DIR_PATH, "../test_ai_prefix.p"), test_pre_ai2) to_binary(os.path.join(DIR_PATH, "../test_ai_postfix.p"), test_pos_ai2) to_binary(os.path.join(DIR_PATH, "../test_ai_infix.p"), test_inf_ai2) # AI2 training data pre_ai2 = convert_to(AI2, "prefix") pos_ai2 = convert_to(AI2, "postfix") if KEEP_INFIX_PARENTHESIS: inf_ai2 = remove_variables(AI2) inf_ai2 = inf_ai2[:len(pos_ai2)] else: inf_ai2 = convert_to(AI2, "infix") if MAKE_IND_SETS:
def calculate_address(pcs, init, size, ipsize): ipinit = init pcs.sort(reverse=True) for ip in pcs: ip_part = ipinit.split('.') tmp_size = len(to_binary(ip)) if ip == tmp_size: tmp_size = tmp_size - 1 tm = ipsize - tmp_size ip_a = [] m_a = [] n_a = [] # ip bits # print(ip_part) for ipp in ip_part: tb = binary_fixed(to_binary(int(ipp)), size) # print(tb) for i in range(0, size): ip_a.append(tb[i]) # mac bits for i in range(0, ipsize): if (i < tm): m_a.append(1) else: m_a.append(0) # na bits for i in range(0, ipsize): n_a.append(int(ip_a[i]) and m_a[i]) # ba bits b_a = ip_a.copy() for i in range(tm, ipsize): b_a[i] = 1 # to decimal sip_a = [] sm_a = [] sn_a = [] sb_a = [] sip = "" sm = "" sn = "" sb = "" for i in range(0, ipsize): if (i % size) == 0 and i != 0: sip_a.append(sip) sip = "" sm_a.append(sm) sm = "" sn_a.append(sn) sn = "" sb_a.append(sb) sb = "" sip = sip + str(ip_a[i]) sm = sm + str(m_a[i]) sn = sn + str(n_a[i]) sb = sb + str(b_a[i]) sip_a.append(sip) sm_a.append(sm) sn_a.append(sn) sb_a.append(sb) print_ips(sip_a, sm_a, sn_a, sb_a, 13, size + 2, ipsize) ipinit = next_ip(sb_a)
PROBLEM_LIST = AI2 + COMMONCORE + ILLINOIS + MAWPS + GENERATED # Randomize random.shuffle(PROBLEM_LIST) # AI2 testing data test_pre_ai2 = convert_to(AI2_TEST, "prefix") test_pos_ai2 = convert_to(AI2_TEST, "postfix") if KEEP_INFIX_PARENTHESIS: test_inf_ai2 = remove_variables(AI2_TEST) test_inf_ai2 = test_inf_ai2[:len(test_pos_ai2)] else: test_inf_ai2 = convert_to(AI2_TEST, "infix") to_binary(os.path.join(DIR_PATH, "../test_ai_prefix.p"), test_pre_ai2) to_binary(os.path.join(DIR_PATH, "../test_ai_postfix.p"), test_pos_ai2) to_binary(os.path.join(DIR_PATH, "../test_ai_infix.p"), test_inf_ai2) # AI2 training data pre_ai2 = convert_to(AI2, "prefix") pos_ai2 = convert_to(AI2, "postfix") if KEEP_INFIX_PARENTHESIS: inf_ai2 = remove_variables(AI2) inf_ai2 = inf_ai2[:len(pos_ai2)] else: inf_ai2 = convert_to(AI2, "infix") if MAKE_IND_SETS: to_binary(os.path.join(DIR_PATH, "../train_ai_prefix.p"), pre_ai2) to_binary(os.path.join(DIR_PATH, "../train_ai_postfix.p"), pos_ai2)
from os import path import utils import NeuralNetworks ############################################################################## FILE_R = "text2.txt" FILE_W = "resultText2" MODEL_FILENAME = "rnn_model.h5" DATA_FILENAME = "data2" COUNT_CLASS = 2 BATCH = 1 LENGTH_SEQ = 20 COUNT_PARAMETERS = 6 ############################################################################## all_x, all_y, all_z = utils.unpack_train_data(DATA_FILENAME) x, z = utils.prepare_real_data(all_x, all_z, LENGTH_SEQ) if path.exists(MODEL_FILENAME): nn = NeuralNetworks.load_model(MODEL_FILENAME) y = utils.to_binary(nn.predict(x, BATCH)) utils.markup_text(FILE_W, FILE_R, y, z, LENGTH_SEQ) else: print("not found model nn") exit()
def predict(self, x, batch_size=32): return utils.to_binary(self.model.predict(x, batch_size=batch_size))
def main(): running = True while running: mode = input('Host? ').lower() if mode == 'y' or mode == 'yes' or mode == 'host': print('Local pub_key: ', utils.to_binary(ecc.encoding.enc_point(creds._pub[1]))) TCP_IP = my_addr TCP_PORT = 4444 BUFFER_SIZE = 2048 # Normally 1024, but we want fast response s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((TCP_IP, TCP_PORT)) s.listen(1) conn, addr = s.accept() print('Connection address:', addr) while 1: data = conn.recv(BUFFER_SIZE) if not data: break data_obj = fancy_shit(data) if 'mcv_seif' in data_obj: msg = creds.decrypt(bytes.decode(data_obj['_pub'])) print(msg) other_creds = Key((521, utils.string_to_point(msg))) ipmsg = creds.decrypt(bytes.decode(data_obj['ip_msg'])) print(other_creds.validate()) if other_creds.verify(data_obj['ip_msg'], bytes.decode(data_obj['ip_sig'])): print('Successful connection!!!!!') conn.close() break print("(host) received data") conn.send(data) conn.close() s.close() print('(host) socket closed') else: TCP_IP = input('ip_addr: ') TCP_PORT = 4444 BUFFER_SIZE = 2048 other_creds = Key(( 521, ecc.encoding.dec_point( 'áØÄ\x87ª`ÝÓ\x92\x8c\x9eh";ûX\x1cFÈ#Qn\x00î&7Lýùäj\ræ\x9c\x07{ºÃ\xadöâ\x10b,zta"\x18«q\x8b±\x00\x02Ucé(7\x8ax\tqtoM-,N\x0b\x04ÖÂÿAø\nWÕçH`[]3úJÕsaÓi~ä\x17·\xa0\x1e\x0c\x18¶Gb\x08}MÝ\x13l\x04\x8aÄåaËÞo\x9f¹\x95L\x7f?yÀr»\x1c\x8d' ))) if not other_creds.validate(): print('Invalid host key') break enc_pub = other_creds.encrypt( utils.to_binary(utils.point_to_string(creds._pub[1]))) signed_ip = creds.sign(utils.to_binary(my_addr)) enc_ip = other_creds.encrypt(utils.to_binary(my_addr)) MESSAGE = utils.to_binary( '"mcv_seif":1,"_pub":{},"ip_sig":{},"ip_msg":{}'.format( enc_pub, signed_ip, enc_ip)) print(fancy_shit(MESSAGE)) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((TCP_IP, TCP_PORT)) s.send(MESSAGE) data = s.recv(BUFFER_SIZE) s.close() print('(client) socket closed')
cost = W1 = W2 = W3 = b1 = b2 = b3 = None for i in range(epochs): cost, W1, W2, W3, b1, b2, b3 = train(X_train, y_train, 0.1) if i % 100 == 0: print('Cost on epoch %i: %s' %(i, cost)) predictor = define_predict(W1, b1, W2, b2, W3, b3) #PREDICTING THE OUTPUT y_train_hat = predictor(X_train) y_dev_hat = predictor(X_dev) y_test_hat = predictor(X_test) #CONVERTING TO BINARY OUTPUT from utils import to_binary y_train_hat = to_binary(y_train_hat) y_dev_hat = to_binary(y_dev_hat) y_test_hat = to_binary(y_test_hat) #CHECKING ACCURACY from sklearn.metrics import accuracy_score accuracy_score(y_train[0], y_train_hat[0], normalize=True) #CHECKING RECALL from sklearn.metrics import recall_score recall_score(y_train[0], y_train_hat[0]) #CHECKING F1 SCORE from sklearn.metrics import f1_score f1_score(y_train[0], y_train_hat[0])