def multiply_karatsuba(x, y): """ Multiplies two numbers represented as arrays using the Karatsuba algorithm, falling back on grade school algorithm for the base case :param x: []int :param y: []int :rtype []int """ x, y = match_padding(x, y) a, b = split(x) c, d = split(y) if len(x) == 1: return multiply_simple(x, y) res_1 = multiply_karatsuba(a, c) res_2 = multiply_karatsuba(b, d) partial = multiply_karatsuba(add(a, b), add(c, d)) # res_3 is partial - res_1 - res_2. # To simplify, just add res_1 and res_2 then subtract that sum from partial res_3 = subtract(partial, add(res_1, res_2)) res = add(pad(res_1, len(x), 'right'), res_2, pad(res_3, (len(x) + 1) // 2, 'right')) return res
def compute_validation_outputs(model, val_iter, field, optional_names=[]): loss, predictions, answers = [], [], [] outputs = [[] for _ in range(len(optional_names))] for batch_idx, batch in enumerate(val_iter): l, p = model(batch) loss.append(l) predictions.append(pad(p, 150, dim=-1, val=field.vocab.stoi['<pad>'])) a = None if hasattr(batch, 'wikisql_id'): a = batch.wikisql_id.data.cpu() elif hasattr(batch, 'squad_id'): a = batch.squad_id.data.cpu() elif hasattr(batch, 'woz_id'): a = batch.woz_id.data.cpu() else: a = pad(batch.answer.data.cpu(), 150, dim=-1, val=field.vocab.stoi['<pad>']) answers.append(a) for opt_idx, optional_name in enumerate(optional_names): outputs[opt_idx].append(getattr(batch, optional_name).data.cpu()) loss = torch.cat(loss, 0) if loss[0] is not None else None predictions = torch.cat(predictions, 0) answers = torch.cat(answers, 0) return loss, predictions, answers, [ torch.cat([ pad(x, 150, dim=-1, val=field.vocab.stoi['<pad>']) for x in output ], 0) for output in outputs ]
def multiply_karatsuba_parallel(x, y, key=None): """ Multiplies two numbers represented as arrays using the Karatsuba algorithm, falling back on grade school algorithm for the base case :param x: []int :param y: []int :rtype []int """ x, y = match_padding(x, y) a, b = split(x) c, d = split(y) # for base case, go simple if len(x) == 1: return multiply_simple(x, y) # for big numbers, go parallel if len(x) > 300: # generate random ids for the subprocess outputs r1 = random.random() r2 = random.random() r3 = random.random() # run the sub-multiplications in parallel p1 = Process(target=multiply_karatsuba_parallel, args=[a, c, r1]) p2 = Process(target=multiply_karatsuba_parallel, args=[b, d, r2]) p3 = Process(target=multiply_karatsuba_parallel, args=[add(a, b), add(c, d), r3]) p1.start() p2.start() p3.start() p1.join() p2.join() p3.join() # get the results res_1 = return_dict[r1] res_2 = return_dict[r2] partial = return_dict[r3] # for smaller numbers, don't bother parallelizing else: res_1 = multiply_karatsuba_parallel(a, c) res_2 = multiply_karatsuba_parallel(b, d) partial = multiply_karatsuba_parallel(add(a, b), add(c, d)) # do the karatsuba shuffle res_3 = subtract(partial, add(res_1, res_2)) res = add(pad(res_1, len(x), 'right'), res_2, pad(res_3, (len(x) + 1) // 2, 'right')) # if we are in parallel mode, write the result to the global dict if key is not None: return_dict[key] = res return res
def __build_do87(self,data): # encode data enc = self.des3enc(pad(data)) # encode length of: encrypted data + one more for # padding content indicator l = ber_tlv_len(len(enc)+1) return [0x87] + l + [0x01] + enc
def counter(self): ctr = self.iv[:] offsetstr = hex(self.ivoffset)[2:] if len(offsetstr) > 8: # if ivoffset gets VERY large, need to pad to ... 16, 24 raise Exception('ivoffset to large... need to fix') offset = pad(offsetstr, 8, '0') l = len(offset) i=0 offsets = [] while i<l: offsets.append( int( offset[i] + offset[i + 1], 16 ) ) i+=2 offsets.reverse() l = len(offsets) carryover = 0 i=0 while i<l: offsets[i] += carryover ctr[i] += offsets[i] carryover = 1 if ctr[i] >= 256 else 0 ctr[i] %= 256 i += 1 self.ivoffset += 1 toreturn = ''.join(map(chr, ctr)) return toreturn
def encrypt_bytes(self, f_bytes, key, iv): """ Encrypts f_bytes using AES in CBC mode """ AES_cip = AES.new(key, AES.MODE_CBC, iv) f_bytes = util.pad(f_bytes, AES.block_size) cipher = AES_cip.encrypt(f_bytes) return cipher
def encrypt_filename(self, name, key): """ Encrypts filename using AES in ECB mode """ AES_cipher = AES.new(key, AES.MODE_ECB) name = util.pad(name.encode(), AES.block_size) cipher = AES_cipher.encrypt(name) return cipher.hex()
def setup_validation_data(self, filename): """Read a validation set from a file.""" _, src_seqs, tgt_indices = read_validation_file( path.join(self.data_dir, filename), self.src_indexer, self.tgt_indexer) src_seqs, tgt_indices = drop_oov_from_validation_set( src_seqs, tgt_indices, self.src_n_vocab, self.tgt_n_vocab) self.src_seqs = torch.LongTensor(pad(src_seqs)) self.tgt_indices = torch.LongTensor(tgt_indices)
def prnBase( cfg, gen=False ): evals="~" avg="~" std="~" skew="~" best="~" genn="~" diversity=0 if gen != False: avg = round( gen.average( ), 4 ) genn = gen.num evals = gen.fitEvals diversity = len(gen.fitTable.data) std=round( gen.stdev( ), 4 ) skew=round( gen.skew( ), 1 ) best=round( gen.max( ), 4 ) out = "" if int(cfg[MAIN][TOTAL_RUNS]) >= 10: out += "\t" out += util.pad(genn, cfg[TERMINATION][GENERATION_LIMIT]) out += "\t" if cfg[TERMINATION][TYPE] == GENERATIONAL_LIMIT: out += "\t" if math.log(int(cfg[TERMINATION][GENERATION_LIMIT]), 10) >= 12: out += "\t" out += util.pad(evals, cfg[TERMINATION][EVALUATION_LIMIT]) if cfg[TERMINATION][TYPE] == FITNESS_EVALUATION_LIMIT and math.log(int(cfg[TERMINATION][EVALUATION_LIMIT]), 10) >= 3: out += "\t" out += "\t" out += str(avg) out += "\t" out += str(skew) out += "\t" out += str(std) out += "\t" out += str(best) out += "\t" out += str(diversity) out += "\t" util.delprn(out, 1)
def encrypt(self, m): plaintext = pad(m, self._block_size) # plaintext = m assert len(plaintext) % self._block_size == 0 blocks = [] for i in progressbar.progressbar(range(0, len(plaintext), self._block_size)): plaintext_block = plaintext[i:i + self._block_size] block = self._encrypt_block(plaintext_block) blocks.append(block) return b"".join(blocks)
def __init__(self, size=5, pad=None, device='cuda'): super(MedianFilterWeighted3d, self).__init__() try: size[0] except TypeError: size = (size, size, size) kernel = torch.ones((size[0], size[1], size[2]), device=device) / (size[0] * size[1] * size[2]) kernel = kernel.view(1, 1, size[0], size[1], size[2]) if pad is None: pad = util.pad(size) self.pad = pad[::-1] self.weights = kernel
def __init__(self, kernel_size=5, sigma=2, pad=None, device='cuda'): super(GaussBlur3d, self).__init__() try: kernel_size[0] except TypeError: kernel_size = (kernel_size, kernel_size, kernel_size) kernel = util.gaussian(kernel_size, sigma, device=device) kernel = kernel.view(1, 1, kernel_size[0], kernel_size[1], kernel_size[2]) if pad is None: pad = util.pad(kernel_size) self.pad = pad[::-1] self.weights = kernel
def compute_validation_outputs(model, val_iter, field, optional_names=[]): loss, predictions, answers = [], [], [] outputs = [[] for _ in range(len(optional_names))] for batch_idx, batch in enumerate(val_iter): l, p = model(batch) loss.append(l) predictions.append(pad(p, 150, dim=-1, val=field.vocab.stoi['<pad>'])) a = None if hasattr(batch, 'wikisql_id'): a = batch.wikisql_id.data.cpu() elif hasattr(batch, 'squad_id'): a = batch.squad_id.data.cpu() elif hasattr(batch, 'woz_id'): a = batch.woz_id.data.cpu() else: a = pad(batch.answer.data.cpu(), 150, dim=-1, val=field.vocab.stoi['<pad>']) answers.append(a) for opt_idx, optional_name in enumerate(optional_names): outputs[opt_idx].append(getattr(batch, optional_name).data.cpu()) loss = torch.cat(loss, 0) if loss[0] is not None else None predictions = torch.cat(predictions, 0) answers = torch.cat(answers, 0) return loss, predictions, answers, [torch.cat([pad(x, 150, dim=-1, val=field.vocab.stoi['<pad>']) for x in output], 0) for output in outputs]
def __init__(self, size=5, pad=None, device='cuda'): super(MedianFilter3d, self).__init__() try: size[0] except TypeError: size = (size, size, size) kernel = torch.zeros( (size[0] * size[1] * size[2], size[0], size[1], size[2]), device=device) for i in range(size[0]): for j in range(size[1]): for k in range(size[2]): kernel[i + j * size[0] + k * size[0] * size[1], i, j, k] = 1 if pad is None: pad = util.pad(size) self.pad = pad[::-1] self.weights = kernel.unsqueeze(1)
def setup_validation_data(self, filename): """Read a validation set from a file.""" src_indices, src_seqs, tgt_indices = read_validation_file( path.join(self.data_dir, filename), self.src_indexer, self.tgt_indexer) # Drop pairs that contain OOV words (subwords) src_seqs, tgt_indices = drop_oov_from_validation_set( src_seqs, tgt_indices, self.src_n_vocab, self.tgt_n_vocab) valid = {} valid['valid_src_subword_ids'] = torch.LongTensor(pad(src_seqs)) # if not self.params.disable_cuda and torch.cuda.is_available(): # TODO # valid['valid_src_subword_ids'] = valid['valid_src_subword_ids'].cuda() valid['valid_src_word_ids'] = src_indices valid['valid_tgt_word_ids'] = tgt_indices valid['gold'] = defaultdict(list) for src, tgt in zip(src_indices, tgt_indices): valid['gold'][src].append(tgt) return valid
def go(arg): tbw = SummaryWriter(log_dir=arg.tb_dir) with open(arg.data, 'r') as file: lines = file.readlines() print('Creating word indices') dist = Counter() for line in lines: dist.update(util.tokenize(line)) vocab = dist.most_common(arg.max_vocab - len(EXTRA_SYMBOLS)) i2w = EXTRA_SYMBOLS + [w[0] for w in vocab] w2i = {word:ix for ix, word in enumerate(i2w)} data = [] suff = [EOS] if arg.add_eos else [] for line in lines: words = util.tokenize(line) indices = [] for word in words: if word in w2i: indices.append(w2i[word]) else: indices.add(UNK) if len(indices) > 0: data.append(indices + suff) data.sort(key= lambda x : len(x)) vocab_size = len(i2w) print('vocabulary size', vocab_size) print('top 100 words:', i2w[:100]) print('sentence lengths ', [len(s) for s in data]) def decode(indices): sentence = '' for id in indices: if id == PAD: break sentence += i2w[id] + ' ' return sentence s = random.choice(data) print('random sentence', s) print(' ', decode(s)) ## Set up the model embedding = torch.nn.Embedding(num_embeddings=vocab_size, embedding_dim=arg.embedding_size) seq_enc = models.SeqEncoder(vocab_size=vocab_size, embedding=embedding, zsize=arg.latent_size) seq_dec = models.SeqDecoder(vocab_size=vocab_size, embedding=embedding, zsize=arg.latent_size) mods = [seq_enc, seq_dec] if torch.cuda.is_available(): for model in mods: model.cuda() params = [] for model in mods: params.extend(model.parameters()) optimizer = Adam(params, lr=arg.lr) instances_seen = 0 for e in range(arg.epochs): if arg.annealing_mode == None or arg.annealing_mode == 'none': weight = 1 elif arg.annealing_mode == 'linear': weight = util.lin_anneal(e, arg.epochs) elif arg.annealing_mode == 'logistic': weight = util.log_anneal(e, arg.epochs) else: raise Exception('Annea;ing mode {} not recognized'.format(arg.annealing_mode)) print('Epoch {}, setting KL weight to {}'.format(e, weight)) for fr in tqdm.trange(0, len(data), arg.batch_size): if arg.instance_limit is not None and fr > arg.instance_limit: break to = min(len(data), fr + arg.batch_size) batch = data[fr:to] batch, lengths = util.pad(batch) # Created shifted versions b, s = batch.size() # Input for the decoder batch_teacher = torch.cat([torch.ones(b, 1, dtype=torch.long), batch], dim=1) batch_out = torch.cat([batch, torch.zeros(b, 1, dtype=torch.long)], dim=1) lengths = torch.LongTensor(lengths) if torch.cuda.is_available(): batch = batch.cuda() batch_teacher = batch_teacher.cuda() batch_out = batch_out.cuda() lengths = lengths.cuda() batch = Variable(batch) batch_teacher = Variable(batch_teacher) batch_out = Variable(batch_out) lengths = Variable(lengths) z = seq_enc(batch, lengths) kl = util.kl_loss(*z) rec = seq_dec(util.sample(*z), batch_teacher, lengths + 1) rec = rec.transpose(1, 2) rl = nll_loss(rec, batch_out, reduce=False).view(b, -1) rl = rl.sum(dim=1) loss = (rl + weight * kl).mean() #- backward pass optimizer.zero_grad() loss.backward() optimizer.step() instances_seen += b tbw.add_scalar('lang/kl', float(kl.mean()), instances_seen) tbw.add_scalar('lang/rec', float(rl.mean()), instances_seen) tbw.add_scalar('lang', float(loss), instances_seen) # Interpolate for r in range(REP): print('Interpolation, repeat', r) z1, z2 = torch.randn(2, arg.latent_size) if torch.cuda.is_available(): z1, z2 = z1.cuda(), z2.cuda() zs = util.slerp(z1, z2, 10) if arg.original_sampling: print('== sentences==') sentences = seq_dec.sample_old(z=zs) else: print('== sentences (temp={}) =='.format(TEMPS[r])) sentences = seq_dec.sample(z=zs, temperature=TEMPS[r]) for s in sentences: print(' ', decode(s))
def main(args): global verbose verbose = args.verbose # Read subword sequences and embeddings if verbose: logger.info('Load subwords from ' + args.path_subwords) data = dict(np.load(args.path_subwords)) N = data['seqs'].shape[0] D = data['W'].shape[1] W = np.r_[np.zeros((1, D)), data['W']] seqs = np.array([[v + 1 for v in seq] for seq in data['seqs']]) # 0=PAD # Load a trained transformer if verbose: logger.info('Load a transformer from ' + args.path_transformer) transformer = SubwordEmbedding(D, n_layers=args.n_layers) transformer.load(args.path_transformer) # Vocabularies (words) vocab = [] with open(args.path_original) as f: next(f) # skip a header for i, line in enumerate(f): if i == N: # reached the vocabulary size break vocab.append(line.split(' ', 1)[0]) batch_size = args.batch_size n_batches = N // batch_size + int(N % batch_size > 0) # number of batches batches = [ np.arange(n * batch_size, min(N, (n + 1) * batch_size)) for n in range(n_batches) ] # Transform subword embeddings and aggregate them to word embeddings def embedding_layer(idx_seqs): # Imitating embeddings.Embedding class return torch.FloatTensor([[W[idx] for idx in idx_seq] for idx_seq in idx_seqs]) if verbose: logger.info('Converting...') vecs = [] for batch in tqdm(batches, total=n_batches): batch_seqs = torch.LongTensor(pad(seqs[batch])) batch_seqs.requires_grad = False vecs += [ vec.detach().numpy() for vec in transformer(batch_seqs, embedding_layer) ] # Output to file in text word2vec format if verbose: logger.info('Output to ' + args.path_output) with open(args.path_output, 'w') as f: f.write('{N} {D}\n'.format(N=N, D=D)) for word, vec in zip(vocab, vecs): f.write('{word} {vec}\n'.format(word=word, vec=' '.join(str(v) for v in vec))) return 0
def encryptData(key, data): """Encrypts the apk data using the specified AES key""" aes = AES.new(key, AES.MODE_ECB) return ''.join(aes.encrypt(util.pad(c, constants.paddingSize)) for c in util.chunk(data, constants.blockSize))
logger.info(f"Finding {N} farthest away from the mean") oddities = nlargest(N, zip(dist, util.image_ids())) logger.info(f"Finished histogram mean outliers") return oddities if __name__ == "__main__": import time, timeit if True: a1, a2, a3 = time.time(), time.process_time(), timeit.default_timer() result = frequency_mean(10) b1, b2, b3 = time.time(), time.process_time(), timeit.default_timer() #print(b1-a1, b2-a2, b3-a3) #print(result) with Figure(1, 1) as fig: ax = fig.ax[0, 0] for error, key in result: img = util.pad(util.image(key), 100, 100) ax.imshow(img, cmap="gray") fig.update(2) input("Press any key to continue")
img = center(img) ax.imshow(img, cmap="gray") fig.update(1) #--- Fixed shift if False: with Figure(1, 1) as fig: ax = fig.ax[0, 0] key = ["3337", "1590", "1377"][0] for img in util.images(): img = util.pad(img, 100, 100) # angle = PCA_angle(img) / tau * 360 # img = rotate(img, angle=angle) img = shift(img, 20, 50) ax.clear() ax.imshow(img, cmap="gray") fig.update() #--- PCA angles if False: for img in util.progress(util.images()):
def forward(self, input_sentences, input_sentence_length, input_conversation_length, input_masks): """ Args: input_sentences: (Variable, LongTensor) [num_sentences, seq_len] target_sentences: (Variable, LongTensor) [num_sentences, seq_len] Return: decoder_outputs: (Variable, FloatTensor) - train: [batch_size, seq_len, vocab_size] - eval: [batch_size, seq_len] """ num_sentences = input_sentences.size(0) max_len = input_conversation_length.max().item() # encoder_outputs: [num_sentences, max_source_length, hidden_size * direction] # encoder_hidden: [num_layers * direction, num_sentences, hidden_size] # encoder_outputs, encoder_hidden = self.encoder(input_sentences, # input_sentence_length) all_encoder_layers, _ = self.encoder(input_sentences, token_type_ids=None, attention_mask=input_masks) bert_output = [] for idx in range(self.config.num_bert_layers): layer = all_encoder_layers[idx] bert_output.append(layer[:, 0, :]) bert_output = torch.stack(bert_output, dim=1) bert_output = torch.mean(bert_output, dim=1, keepdim=False) # encoder_hidden: [num_sentences, num_layers * direction * hidden_size] encoder_hidden = bert_output # pad and pack encoder_hidden start = torch.cumsum( torch.cat((to_var(input_conversation_length.data.new(1).zero_()), input_conversation_length[:-1])), 0) # encoder_hidden: [batch_size, max_len, num_layers * direction * hidden_size] encoder_hidden = torch.stack([ pad(encoder_hidden.narrow(0, s, l), max_len) for s, l in zip( start.data.tolist(), input_conversation_length.data.tolist()) ], 0) # context_outputs: [batch_size, max_len, context_size] context_outputs, context_last_hidden = self.context_encoder( encoder_hidden, input_conversation_length) # flatten outputs # context_outputs: [num_sentences, context_size] context_outputs = torch.cat([ context_outputs[i, :l, :] for i, l in enumerate(input_conversation_length.data) ]) context_outputs = self.dropoutLayer(context_outputs) # project context_outputs to decoder init state decoder_init = self.context2decoder(context_outputs) output = self.decoder2output(decoder_init) return output
def denoise(flow_h5_path, pv_path, output_path, pv_series=None, surface_size=7, method='frames', interpolate=False, vector_mult=1, frame_filter=None, start_from=None, stop_at=None, device='cuda', overwrite=True): """ _filters labels with a 3_d gaussian. :param flow_h5_path: String tuple. Tuple containing paths to (flow_forward.h5, flow_backward.h5) :param pv_path: String. Path to previous iteration folder. :param output_path: String. Output folder. :param pv_series: Int array. Frames to consider when constructing th 3_d volume to be filtered. Ex [0, 5] = 0 - current frame, 5 - frames at -5,+5 distance. :param surface_size: Float. Filter size on the YX axes, in pixels. :param method: String. Method for 3D volume construction. Possible values: 'self' - project current frame along flow vectors, 'frames' - project series frame. :param interpolate: Bool. Bilinearly interpolate coordinates during flow projection. Might be useful for low resolution data and long propagation distances. :param vector_mult: Float. Multiplies default flow vectors by the specified amount. :param frame_filter: Function. Receives frame number and returns 'True' for any frame that should be skipped. Useful for evaluation. :param start_from: Int. Start from frame number. :param stop_at: Int. Stop on frame number. :param device: py_torch device to run on. :param overwrite: Bool. Overwrite previous results. :return: 0 if completed successfully. """ if not os.path.exists(output_path): os.makedirs(output_path) if pv_series is None: pv_series = [0] # meta pv_maps = sorted(os.listdir(pv_path)) pv_no = [_frame_no(name) for name in pv_maps] noy, nox, noc = toio.load(os.path.join(pv_path, pv_maps[0]), device=device)['map'].shape basename = _basename(pv_maps[0]) pv_series = sorted(pv_series) depth = pv_series[-1] nof = pv_no[-1] cur_times = sum([i == 0 for i in pv_series]) pv_series = [i for i in pv_series if i > 0] depth_size = len(pv_series) * 2 + cur_times depth_sigma = depth_size / 2.5 surface_sigma = surface_size / 2.5 if start_from is None: start_from = pv_no[0] if stop_at is None or stop_at > pv_no[-1]: stop_at = pv_no[-1] # configure filter pad = util.pad((0, surface_size, surface_size)) denoiser = blocks.GaussBlur3d((depth_size, surface_size, surface_size), (depth_sigma, surface_sigma, surface_sigma), pad=pad, device=device) # process for i in range(max(depth + pv_no[0], start_from), min(nof - depth + 1, stop_at)): path = os.path.join(output_path, basename + '_{:06d}'.format(i) + '.npz') # only compute frames that aren't filtered if frame_filter is not None and frame_filter(i): continue # overwrite if not overwrite and os.path.exists(path): continue # verbose print('{:06d}'.format(i)) # load flows flow_data_fwd = h5py.File(flow_h5_path[0], 'r') flow_data_fwd = flow_data_fwd['flow'][i:i + depth] flow_data_fwd = torch.from_numpy(flow_data_fwd).to(device).flip(3) flow_data_bkw = h5py.File(flow_h5_path[1], 'r') flow_data_bkw = flow_data_bkw['flow'][i - depth:i] flow_data_bkw = torch.from_numpy(flow_data_bkw).to(device).flip(0).flip(3) # load map vote_map = toio.load(os.path.join(pv_path, pv_maps[i - pv_no[0]]), device=device)['votes'].type(torch.float) # 3d frame-time voxel votes if method == 'self': fw_maps = _flow_align(flow_data_fwd, vote_map, pv_series, vector_mult=vector_mult, interpolate=interpolate) bk_maps = _flow_align(flow_data_bkw, vote_map, pv_series, vector_mult=vector_mult, interpolate=interpolate) elif method == 'frames': fw_maps = torch.zeros((noy, nox, noc, len(pv_series)), device=device, dtype=torch.float) bk_maps = torch.zeros((noy, nox, noc, len(pv_series)), device=device, dtype=torch.float) for j, k in enumerate(pv_series): pre_map = toio.load(os.path.join(pv_path, pv_maps[i - k - pv_no[0]]), device=device)['votes'] nxt_map = toio.load(os.path.join(pv_path, pv_maps[i + k - pv_no[0]]), device=device)['votes'] bk_maps[..., j] = _flow_end_map(flow_data_fwd[depth - k:depth], pre_map, vector_mult=vector_mult, interpolate=interpolate) fw_maps[..., j] = _flow_end_map(flow_data_bkw[depth - k:depth], nxt_map, vector_mult=vector_mult, interpolate=interpolate) del pre_map, nxt_map elif method == 'noalign': fw_maps = torch.zeros((noy, nox, noc, len(pv_series)), device=device, dtype=torch.float) bk_maps = torch.zeros((noy, nox, noc, len(pv_series)), device=device, dtype=torch.float) for j, k in enumerate(pv_series): bk_maps[..., j] = toio.load(os.path.join(pv_path, pv_maps[i - k - pv_no[0]]), device=device)['votes'] fw_maps[..., j] = toio.load(os.path.join(pv_path, pv_maps[i + k - pv_no[0]]), device=device)['votes'] else: raise NotImplementedError votes = torch.cat((bk_maps.flip(3), vote_map.unsqueeze(-1).expand(-1, -1, -1, cur_times), fw_maps), dim=3) # denoise votes = votes.permute((2, 3, 0, 1)) votes = votes.unsqueeze(0) votes = denoiser(votes).squeeze() votes = votes.permute((1, 2, 0)) # extract final map map = torch.argmax(votes, 2) map = classmap.logical(map, noc) # save np.savez_compressed(path, map=map.cpu().numpy().astype(bool), votes=votes.cpu().numpy()) # copy the rest if frame_filter is None: for i in list(range(depth)) + list(range(len(pv_maps) - depth, len(pv_maps))): copyfile(os.path.join(pv_path, pv_maps[i]), os.path.join(output_path, pv_maps[i])) # verbose # print('done!') return 0
def sendMoveToKafra(self, gamesocket, index, quantity): packet='\x94\x00' + util.pad(3) + util.packWord(index) + util.pad(12) +util.packWord(quantity)+ util.pad(2) gamesocket.send(packet)
with Figure(2, 5) as fig: axes = get_axes(2, 5, fig) arrow(axes[..., 2]) for col_index in [0, 1, 3, 4]: clean(axes[..., col_index]) square(axes[..., col_index]) angles = lambda: (util.images().pad().map(transform.PCA_angle)) # block 1 img_mean = util.mean(util.images().pad(100, 100)) img_3 = [ util.pad(util.image(i), 100, 100) for i in ["1377", "1590", "9728"] ] samples = [img_mean] + img_3 block_imshow(1, axes, samples) # block 2 angle_mean = util.angle_mean(angles()) angle_3 = list(map(transform.PCA_angle, img_3)) transformed_samples = [angle_mean] + angle_3 block_circle(2, axes, transformed_samples) fig.save("figure/example.pdf")
def sendAreaSkill(self, gamesocket, skillNum, level, x, y): #packet=struct.pack('2s9xH5xH2x4s', '\x72\x00', level, skillNum, targetID) packet='\x13\x01'+util.pad(3)+util.packWord(level) + util.pad(8) + util.packWord(skillNum) + util.pad(12) + util.packWord(x) + util.pad(7) + util.packWord(y) gamesocket.send(packet)
def encryptData(key, data): """Encrypts the apk data using the specified AES key""" aes = AES.new(key, AES.MODE_ECB) return ''.join( aes.encrypt(util.pad(c, constants.paddingSize)) for c in util.chunk(data, constants.blockSize))
def go(arg): tbw = SummaryWriter(log_dir=arg.tb_dir) transform = Compose([ Lambda(lambda x: CenterCrop(min(x.size))(x)), Resize(size=(arg.img_size, arg.img_size)), ToTensor() ]) imdir = arg.data_dir + os.sep + 'val2017' anfile = arg.data_dir + os.sep + 'annotations' + os.sep + 'captions_val2017.json' coco_data = coco.CocoCaptions(root=imdir, annFile=anfile, transform=transform) ## Make a dictionary util.ensure(arg.cache_dir) if os.path.isfile(arg.cache_dir + os.sep + 'i2w.pkl'): with open(arg.cache_dir + os.sep + 'i2w.pkl', 'rb') as file: i2w = pickle.load(file) with open(arg.cache_dir + os.sep + 'w2i.pkl', 'rb') as file: w2i = pickle.load(file) print('Word indices loaded.') else: print('Creating word indices') # Why is this so slow? dist = Counter() for i in tqdm.trange(len(coco_data)): for caption in coco_data[i][1]: dist.update(util.tokenize(caption)) vocab = dist.most_common(arg.max_vocab - len(EXTRA_SYMBOLS)) i2w = EXTRA_SYMBOLS + [w[0] for w in vocab] w2i = {word: ix for ix, word in enumerate(i2w)} with open(arg.cache_dir + os.sep + 'i2w.pkl', 'wb') as file: pickle.dump(i2w, file) with open(arg.cache_dir + os.sep + 'w2i.pkl', 'wb') as file: pickle.dump(w2i, file) vocab_size = len(i2w) print('vocabulary size', vocab_size) print('top 100 words:', i2w[:100]) def decode(indices): sentence = '' for id in indices: # if id == PAD: # break sentence += i2w[id] + ' ' return sentence ## Set up the models embedding = torch.nn.Embedding(num_embeddings=vocab_size, embedding_dim=arg.embedding_size) if arg.mode != Mode.style: img_enc = models.ImEncoder(in_size=(arg.img_size, arg.img_size), zsize=arg.latent_size) img_dec = models.ImDecoder(in_size=(arg.img_size, arg.img_size), zsize=arg.latent_size) seq_enc = models.SeqEncoder(vocab_size=vocab_size, embedding=embedding, zsize=arg.latent_size) seq_dec = models.SeqDecoder(vocab_size=vocab_size, embedding=embedding, zsize=arg.latent_size) mods = [img_enc, img_dec, seq_enc, seq_dec] else: img_enc = models.ImEncoder(in_size=(arg.img_size, arg.img_size), zsize=arg.latent_size) img_sty = models.ImEncoder(in_size=(arg.img_size, arg.img_size), zsize=arg.latent_size) img_dec = models.ImDecoder(in_size=(arg.img_size, arg.img_size), zsize=arg.latent_size * 2) seq_enc = models.SeqEncoder(vocab_size=vocab_size, embedding=embedding, zsize=arg.latent_size) seq_sty = models.SeqEncoder(vocab_size=vocab_size, embedding=embedding, zsize=arg.latent_size) seq_dec = models.SeqDecoder(vocab_size=vocab_size, embedding=embedding, zsize=arg.latent_size * 2) mods = [img_enc, img_dec, img_sty, seq_enc, seq_dec, seq_sty] if torch.cuda.is_available(): for model in mods: model.cuda() #- The standard dataloader approach doesn't seem to work with the captions, so we'll do our own batching. # It's a little slower, probably, but it won't be the bottleneck params = [] for model in mods: params.extend(model.parameters()) optimizer = Adam(params, lr=arg.lr) instances_seen = 0 for e in range(arg.epochs): print('epoch', e) for fr in tqdm.trange(0, len(coco_data), arg.batch_size): if arg.instance_limit is not None and fr > arg.instance_limit: break to = min(len(coco_data), fr + arg.batch_size) images = [] captions = [] for i in range(fr, to): images.append(coco_data[i][0].unsqueeze(0)) captions.append(random.choice( coco_data[i] [1])) # we choose one of the available captions at random imbatch = torch.cat(images, dim=0) b, c, w, h = imbatch.size() capbatch = [] # to integer sequence for caption in captions: capbatch.append(util.intseq(util.tokenize(caption), w2i)) capbatch, lengths = util.pad(capbatch) # Created shifted versions b, s = capbatch.size() # Input for the decoder cap_teacher = torch.cat( [torch.ones(b, 1, dtype=torch.long), capbatch], dim=1) cap_out = torch.cat( [capbatch, torch.zeros(b, 1, dtype=torch.long)], dim=1) lengths = torch.LongTensor(lengths) if torch.cuda.is_available(): imbatch = imbatch.cuda() capbatch = capbatch.cuda() cap_teacher = cap_teacher.cuda() cap_out = cap_out.cuda() lengths = lengths.cuda() imbatch = Variable(imbatch) capbatch = Variable(capbatch) cap_teacher = Variable(cap_teacher) cap_out = Variable(cap_out) lengths = Variable(lengths) zimg = img_enc(imbatch) zcap = seq_enc(capbatch, lengths) kl_img = util.kl_loss(*zimg) kl_cap = util.kl_loss(*zcap) zimg_sample = util.sample(*zimg) zcap_sample = util.sample(*zcap) if arg.mode == Mode.style: zimg_sty = img_sty(imbatch) zcap_sty = seq_sty(capbatch, lengths) kl_img_sty = util.kl_loss(*zimg_sty) kl_cap_sty = util.kl_loss(*zcap_sty) zimg_sample_sty = util.sample(*zimg_sty) zcap_sample_sty = util.sample(*zcap_sty) zimg_sample = torch.cat([zimg_sample, zimg_sample_sty], dim=1) zcap_sample = torch.cat([zcap_sample, zcap_sample_sty], dim=1) rec_imgimg = img_dec(zimg_sample) rl_imgimg = binary_cross_entropy(rec_imgimg, imbatch, reduce=False).view(b, -1).sum(dim=1) rec_capcap = seq_dec(zcap_sample, cap_teacher, lengths + 1).transpose(1, 2) rl_capcap = nll_loss(rec_capcap, cap_out, reduce=False).view(b, -1).sum(dim=1) if arg.mode != Mode.independent: rec_capimg = img_dec(zcap_sample) rl_capimg = binary_cross_entropy(rec_capimg, imbatch, reduce=False).view( b, -1).sum(dim=1) rec_imgcap = seq_dec(zimg_sample, cap_teacher, lengths + 1).transpose(1, 2) rl_imgcap = nll_loss(rec_imgcap, cap_out, reduce=False).view(b, -1).sum(dim=1) loss_img = rl_imgimg + kl_img loss_cap = rl_capcap + kl_cap if arg.mode == Mode.coupled: loss_img = loss_img + rl_capimg + kl_img loss_cap = loss_cap + rl_imgcap + kl_cap if arg.mode == Mode.style: loss_img = loss_img + kl_img_sty loss_cap = loss_cap + kl_cap_sty loss = loss_img.mean() + loss_cap.mean() #- backward pass optimizer.zero_grad() loss.backward() optimizer.step() instances_seen += b tbw.add_scalar('score/img/kl', float(kl_img.mean()), instances_seen) tbw.add_scalar('score/imgimg/rec', float(rl_imgimg.mean()), instances_seen) tbw.add_scalar('score/cap/kl', float(kl_cap.mean()), instances_seen) tbw.add_scalar('score/capcap/rec', float(rl_capcap.mean()), instances_seen) tbw.add_scalar('score/loss', float(loss), instances_seen) if arg.mode != Mode.independent: tbw.add_scalar('score/capimg/rec', float(rl_capimg.mean()), instances_seen) tbw.add_scalar('score/imgcap/rec', float(rl_imgcap.mean()), instances_seen) # Interpolate zpairs = [] for r in range(REP): print('Interpolation, repeat', r) l = arg.latent_size if arg.mode != Mode.style else arg.latent_size * 2 z1, z2 = torch.randn(2, l) if torch.cuda.is_available(): z1, z2 = z1.cuda(), z2.cuda() zpairs.append((z1, z2)) zs = util.slerp(z1, z2, 10) print('== sentences (temp={}) =='.format(TEMPS[r])) sentences = seq_dec.sample(z=zs, temperature=TEMPS[r]) for s in sentences: print(' ', decode(s)) print('== images ==') util.interpolate(zpairs, img_dec, name='interpolate.{}'.format(e))