def beam_decode(self, batch, max_len, oov_nums): bos_token = self.data_utils.bos beam_size = self.args.beam_size vocab_size = self.data_utils.vocab_size src = batch['src'].long() src_mask = batch['src_mask'] src_extended = batch['src_extended'].long() memory = self.model.encode(src, src_mask) batch_size = src.size(0) beam = Beam(self.data_utils.pad, bos_token, self.data_utils.eos, beam_size, batch_size, self.args.n_best, True, max_len) ys = torch.full((batch_size, 1), bos_token).type_as(src.data).cuda() log_prob = self.model.decode( memory, src_mask, Variable(ys), Variable( subsequent_mask(ys.size(1)).type_as(src.data).expand( (ys.size(0), ys.size(1), ys.size(1)))), src_extended, oov_nums) # log_prob = [batch_size, 1, voc_size] top_prob, top_indices = torch.topk(input=log_prob, k=beam_size, dim=-1) # print(top_indices) top_prob = top_prob.view(-1, 1) top_indices = top_indices.view(-1, 1) beam.update_prob(top_prob.detach().cpu(), top_indices.detach().cpu()) # [batch_size, 1, beam_size] ys = top_indices top_indices = None # print(ys.size()) ####### repeat var ####### src = torch.repeat_interleave(src, beam_size, dim=0) src_mask = torch.repeat_interleave(src_mask, beam_size, dim=0) #[batch_size, src_len, d_model] -> [batch_size*beam_size, src_len, d_model] memory = torch.repeat_interleave(memory, beam_size, dim=0) # print('max_len', max_len) for t in range(1, max_len): log_prob = self.model.decode( memory, src_mask, Variable(ys), Variable( subsequent_mask(ys.size(1)).type_as(src.data).expand( (ys.size(0), ys.size(1), ys.size(1)))), src) # print('log_prob', log_prob.size()) log_prob = log_prob[:, -1].unsqueeze(1) # print(beam.seq) real_top = beam.advance(log_prob.detach().cpu()) # print(real_top.size()) # print(ys.size()) # print(real_top.size()) ys = torch.cat((ys, real_top.view(-1, 1).cuda()), dim=-1) # print(ys.size()) # print(ys.size()) # print(beam.top_prob) # print(len(beam.seq)) return [beam.seq[0]]
def _extend_beam_for_test(self, beam): # return beam for next step new_beam = Beam(self.model.beam_size) # go over all state in beam for state in beam: # unpacking state pending, prev_score, prev_feats, deps, _ = self._extract_state( state) for i, (tok1, tok2) in enumerate(zip(pending, pending[1:])): # get local features lc_feats = self.model.featex(pending, deps, i) # score of local features scores = self.model.get_score(lc_feats) # global feats go_feats = prev_feats + lc_feats for clas, score in enumerate(scores): arc = self._get_action(clas, tok1, tok2) n_pending, n_deps = self._apply_action(arc, state) # try starter score is zero if prev_score == float('-inf'): n_score = score else: n_score = prev_score + score new_state = self._get_state(n_pending, go_feats, n_score, clas, n_deps) new_beam.add(new_state) return new_beam
def extend_beam_for_parse(self, beam): new_beam = Beam(beam_size=self.model.beam_size) for state in beam: pending = state['pending'] prev_features = state['features'] prev_score = state['score'] arcs = state['arcs'] for attachment_point in xrange(len(pending) - 1): # at this point you could create n new state local_features = features_extract(pending, arcs, attachment_point) # features extract funtion has not be built yet scores = self.model.get_scores(local_features) global_features = prev_features + local_features for cls_id, score in scores.iteritems(): action = get_action(attachment_point, cls_id, self.model.label_hash) # apply action to pending new_pending, new_arcs = apply_action(pending, arcs, action) # create new state if prev_score == float('-inf'): current_score = score else: current_score = prev_score + score new_state = get_state(new_pending, global_features, current_score, cls_id, new_arcs) # add new state to beam new_beam.add(new_state) return new_beam
def parse(self, sent): sent = [ROOT] + sent init_state = get_state(sent) beam = Beam(self.model.beam_size) beam.add(init_state) for i in xrange(len(sent) - 1): beam = self.extend_beam_for_parse(beam) final_state = beam.top() return final_state['arcs']
def test_beam_init(self): n1 = Node(0.,0.,0.) n2 = Node(10.,10.,0.) b1 = Beam(n1,n2) b1.properties['Area'] = 0.1*0.1 self.assertAlmostEqual(b1.length(), sqrt(200.)) self.assertAlmostEqual(b1.volume(), 0.01*sqrt(200.)) self.assertTrue(b1.sizeOfEM() == 12)
def _extend_beam(self, beam, oracle): new_beam = Beam(self.model.beam_size) valid_action = Beam(beam_size=1) for state in beam: pending, prev_score, prev_feats, deps, stt = self._extract_state( state) for i, (tok1, tok2) in enumerate(zip(pending, pending[1:])): lc_feats = self.model.featex(pending, deps, i) scores = self.model.get_score(lc_feats) go_feats = prev_feats + lc_feats for clas, score in scores.iteritems(): arc = self._get_action(clas, tok1, tok2) # stt ensure all action before in state is valid if stt: is_valid = self._check_valid(arc, deps, oracle) n_pending, n_deps = self._apply_action(arc, state) if prev_score == float('-inf'): n_score = score else: n_score = prev_score + score new_state = self._get_state(n_pending, go_feats, n_score, clas, n_deps, is_valid) new_beam.add(new_state) if is_valid: valid_action.add(new_state) return new_beam, valid_action.top()
def decode(model, opts, test_batcher, i2c, i2p): """ Decode the input """ logging.basicConfig(filename=opts.log, level=logging.INFO) if opts.use_cuda: #print "Find GPU enable, using GPU to compute..." model.cuda() torch.cuda.manual_seed(opts.seed) # else: # print "Find GPU unable, using CPU to compute..." result_file = opts.result_file result_writer = codecs.open(result_file, 'w', 'utf-8') t = trange(opts.data_size, desc='DECODE') for iter in t: input, target, pos, target_length, input_length = test_batcher.next() input_tensor = Variable(torch.LongTensor(input)) target_tensor = Variable(torch.LongTensor(target)) pos_tensor = Variable(torch.LongTensor(pos)) if opts.use_cuda: input_tensor = input_tensor.cuda() target_tensor = target_tensor.cuda() pos_tensor = pos_tensor.cuda() encoder_state, encoder_output, pos_feature, _ = model.encode_once( input_tensor, pos_tensor) start_decode = Variable(torch.LongTensor([2])).cuda().unsqueeze(1) beam = Beam(model, opts.beam_size, opts.max_target_len, encoder_state, encoder_output, pos_feature, start_decode, input) hyper = beam.run() raw_input = "" result = "" raw_pos = "" for word in hyper.word_list: result += i2c[word] for word in input[0]: raw_input += i2c[word] for word in pos[0]: if word == 0: break raw_pos += i2p[word] + ";" raw_pos = raw_pos[:-1] result_writer.write(raw_input + '\t' + result + '\t' + raw_pos + '\n') result_writer.close() os.system(('../evaluation/evalm.py --gold %s --guess %s --task 1') % (opts.test, opts.result_file)) log_result('temp.txt', opts)
class PyEpic(object): def __init__(self, inputfile=''): self.beam1 = Beam() self.beam2 = Beam() if inputfile is not '': self.readfrom(inputfile) def readfrom(self, inputfile): glbdict,b1dict,b2dict = epicIO.parse_file(inputfile) self.beam1.read_input(b1dict) self.beam2.read_input(b2dict)
def decode_beam(self, beam_size, batch_size, encoder_states, block_ngram=0, expand_beam=1): dev = self.opts['device'] beams = [ Beam(beam_size, device='cuda', block_ngram=block_ngram, expand_beam=expand_beam) for _ in range(batch_size) ] decoder_input = self.sos_buffer.expand(batch_size * beam_size, 1).to(dev) inds = torch.arange(batch_size).to(dev).unsqueeze(1).repeat( 1, beam_size).view(-1) encoder_states = self.reorder_encoder_states( encoder_states, inds) # not reordering but expanding incr_state = encoder_states[1] for ts in range(self.longest_label): if all((b.done() for b in beams)): break score, incr_state, attn_w_log = self.decoder( decoder_input, incr_state, encoder_states) score = score[:, -1:, :] score = score.view(batch_size, beam_size, -1) score = F.log_softmax(score, dim=-1) for i, b in enumerate(beams): if not b.done(): b.advance(score[i]) incr_state_inds = torch.cat([ beam_size * i + b.get_backtrack_from_current_step() for i, b in enumerate(beams) ]) incr_state = self.reorder_decoder_incremental_state( incr_state, incr_state_inds) selection = torch.cat([ b.get_output_from_current_step() for b in beams ]).unsqueeze(-1) decoder_input = selection for b in beams: b.check_finished() beam_preds_scores = [list(b.get_top_hyp()) for b in beams] for pair in beam_preds_scores: pair[0] = Beam.get_pretty_hypothesis(pair[0]) return beam_preds_scores, beams
def test_beam_transform(self): n1 = Node(0.,0.,0.) n2 = Node(10.,10.,0.) b1 = Beam(n1,n2) T = b1.calcT() p0 = np.dot(T,(0.,0.,0.)) self.almostEqual(p0, (0.,0.,0.)) p1 = np.dot(T,(10.,10.,0.)) self.almostEqual(p1, (sqrt(200.),0.,0.))
def test_beam_transform(self): n1 = Node(0., 0., 0.) n2 = Node(10., 10., 0.) b1 = Beam(n1, n2) T = b1.calcT() p0 = np.dot(T, (0., 0., 0.)) self.almostEqual(p0, (0., 0., 0.)) p1 = np.dot(T, (10., 10., 0.)) self.almostEqual(p1, (sqrt(200.), 0., 0.))
def translate_beam_search(self, img): with torch.no_grad(): memory = self.transformer(img) beam = Beam(beam_size=2, min_length=0, n_top=1, ranker=None, start_token_id=1, end_token_id=2) for _ in range(128): tgt_inp = beam.get_current_state().transpose(0, 1).to( self.device) # TxN decoder_outputs = self.transformer.transformer.forward_decoder( tgt_inp, memory) log_prob = log_softmax(decoder_outputs[:, -1, :].squeeze(0), dim=-1) beam.advance(log_prob.cpu()) if beam.done(): break scores, ks = beam.sort_finished(minimum=1) hypothesises = [] for times, k in ks: hypothesis = beam.get_hypothesis(times, k) hypothesises.append(hypothesis) encode = [1] + [int(i) for i in hypothesises[0][:-1]] return self.vocab.decode(encode)
def predict_one(self, source, num_candidates=5): source_preprocessed = self.preprocess(source) source_tensor = torch.tensor(source_preprocessed).unsqueeze( 0) # why unsqueeze? length_tensor = torch.tensor(len(source_preprocessed)).unsqueeze(0) sources_mask = pad_masking(source_tensor, source_tensor.size(1)) memory_mask = pad_masking(source_tensor, 1) memory = self.model.encoder(source_tensor, sources_mask) decoder_state = self.model.decoder.init_decoder_state() # print('decoder_state src', decoder_state.src.shape) # print('previous_input previous_input', decoder_state.previous_input) # print('previous_input previous_layer_inputs ', decoder_state.previous_layer_inputs) # Repeat beam_size times memory_beam = memory.detach().repeat( self.beam_size, 1, 1) # (beam_size, seq_len, hidden_size) beam = Beam(beam_size=self.beam_size, min_length=0, n_top=num_candidates, ranker=None) for _ in range(self.max_length): new_inputs = beam.get_current_state().unsqueeze( 1) # (beam_size, seq_len=1) decoder_outputs, decoder_state = self.model.decoder( new_inputs, memory_beam, memory_mask, state=decoder_state) # decoder_outputs: (beam_size, target_seq_len=1, vocabulary_size) # attentions['std']: (target_seq_len=1, beam_size, source_seq_len) attention = self.model.decoder.decoder_layers[ -1].memory_attention_layer.sublayer.attention beam.advance(decoder_outputs.squeeze(1), attention) beam_current_origin = beam.get_current_origin() # (beam_size, ) decoder_state.beam_update(beam_current_origin) if beam.done(): break scores, ks = beam.sort_finished(minimum=num_candidates) hypothesises, attentions = [], [] for i, (times, k) in enumerate(ks[:num_candidates]): hypothesis, attention = beam.get_hypothesis(times, k) hypothesises.append(hypothesis) attentions.append(attention) self.attentions = attentions self.hypothesises = [[token.item() for token in h] for h in hypothesises] hs = [self.postprocess(h) for h in self.hypothesises] return list(reversed(hs))
def fire_random_beam(ai_settings, screen, aliens, beams): """Fire a beam from a random alien in the fleet""" firing_alien = random.choice(aliens.sprites()) if len(beams) < ai_settings.beams_allowed: new_beam = Beam(ai_settings, screen, firing_alien) ai_settings.alien_channel.play(ai_settings.alien_fire_sound) beams.add(new_beam)
def configure(self): """ Configure the beams from the config source. This is done whenever an instrument is instantiated. :return: """ if self.beams: raise RuntimeError("Beamformer ops already configured.") # get beam names from config beam_names = [] self.beams = {} for k in self.corr.configd: if k.startswith("beam"): bmnm = self.corr.configd[k]["output_products"] if bmnm in beam_names: raise ValueError( "Cannot have more than one beam with " "the name %s. Please check the " "config file." % bmnm ) newbeam = Beam.from_config(k, self.hosts, self.corr.configd, self.corr.speadops) self.beams[newbeam.name] = newbeam beam_names.append(bmnm.strip()) self.logger.info("Found beams: %s" % beam_names) # configure the beams for beam in self.beams.values(): beam.configure() # add the beam data streams to the instrument list for beam in self.beams.values(): self.corr.register_data_stream(beam.data_stream)
def eval_step(self, batch, decoding_strategy='score', dump=False): xs, ys, use_packed = batch.text_vecs, batch.label_vecs, batch.use_packed xs_lens, ys_lens = batch.text_lens, batch.label_lens self.eval_mode() encoder_states = self.encoder(xs, xs_lens, use_packed=use_packed) if decoding_strategy == 'score': assert ys is not None _ = self.compute_loss(encoder_states, xs_lens, ys) if decoding_strategy == 'greedy': scores, preds, attn_w_log = self.decode_greedy( encoder_states, batch.text_vecs.size(0)) preds = torch.stack(preds, dim=1) scores = torch.stack(scores, dim=1) #import ipdb; ipdb.set_trace() pred_lengths = (scores < 0).sum(dim=1).to(scores.device) length_penalties = torch.Tensor([ Beam.get_length_penalty(i) for i in pred_lengths.tolist() ]).to(scores.device) scores_length_penalized = scores.sum(dim=1) / length_penalties pred_scores = tuple( (p, s) for p, s in zip(preds, scores_length_penalized)) if dump is True: _dump = [attn_w_log] return pred_scores, _dump else: return pred_scores if 'beam' in decoding_strategy: beams = self.decode_beam(int(decoding_strategy.split(':')[-1]), len(batch.text_lens), encoder_states) pred_scores = beams return pred_scores
def setup(self, static, Wcent): Nmax = Variable("N_{max}", 5, "-", "max loading") cbar, _ = c_bar(0.5, static.N) sigmaai = Variable("\\sigma_{AI}", 207, "MPa", "aluminum max stress") kappa = Variable("\\kappa", 0.05, "-", "max tip deflection ratio") with Vectorize(static.N - 1): Mr = Variable("M_r", "N*m", "wing section root moment") with Vectorize(static.N): qbar = Variable("\\bar{q}", cbar, "-", "normalized loading") beam = Beam(static.N, qbar) constraints = [ # dimensionalize moment of inertia and young's modulus beam["\\bar{EI}"] <= (8 * static["E"] * static["I"] / Nmax / Wcent / static["b"]**2), Mr == (beam["\\bar{M}"][:-1] * Wcent * Nmax * static["b"] / 4), sigmaai >= Mr / static["S_y"], beam["\\bar{\\delta}"][-1] <= kappa, ] return beam, constraints
def configure(self, *args, **kwargs): """ Configure the beams from the config source. This is done whenever an instrument is instantiated. :return: """ if self.beams: raise RuntimeError('Beamformer ops already configured.') # get beam names from config beam_names = [] self.beams = {} max_pkt_size = self.corr.b_stream_payload_len for section_name in self.corr.configd: if section_name.startswith('beam'): beam = Beam.from_config(section_name, self.hosts, self.corr.configd, self.corr.fops, self.corr.speadops, max_pkt_size=max_pkt_size, *args, **kwargs) if beam.name in beam_names: raise ValueError('Cannot have more than one beam with ' 'the name %s. Please check the ' 'config file.' % beam.name) self.beams[beam.name] = beam beam_names.append(beam.name) self.logger.info('Found {} beams: {}'.format(len(beam_names), beam_names)) # add the beam data streams to the instrument list for beam in self.beams.values(): self.corr.add_data_stream(beam)
def fire_random_beam(ai_settings, screen, aliens, beams): firing_alien = random.choice(aliens.sprites()) if len(beams) < ai_settings.beams_allowed and \ (ai_settings.beam_stamp is None or (abs(pygame.time.get_ticks() - ai_settings.beam_stamp) > ai_settings.beam_time)): new_beam = Beam(ai_settings, screen, firing_alien) firing_alien.fire_weapon() beams.add(new_beam)
def constructBeams(self, beamFile): f = open(beamFile, 'r') tempbeam = [] next(f) for line in f: tempbeam.append(Beam(line)) f.close() return tempbeam
def parse(self, sent): # parse one sent according to current model paramaters # ROOT token at begining of pending sent = [ROOT] + sent # start state init_state = self._get_state(sent) # create a beam beam = Beam(self.model.beam_size) # add state to beam beam.add(init_state) # loop until only one tree left for step in range(len(sent) - 1): # beam of next step beam = self._extend_beam_for_test(beam) # result of parse deps = beam.top()['deps'] return deps
def beam_generate(self,h,c,tembs,vembs,gembs,nerd,beamsz,k): #h,c,tembs,vembs,gembs,rembs = self.encode_inputs(title,entities,graph) #h,c,tembs,vembs,gembs = self.encode_inputs(title,entities,graph) embs = [x for x in [(self.t_attn,tembs),(self.g_attn,gembs),(self.e_attn,vembs)] if x[1] is not None] outp = torch.LongTensor(vembs[0].size(0),1).fill_(self.starttok).cuda() last = h.transpose(0,1) outputs = [] beam = None for i in range(self.maxlen): outp = self.emb_w_vertex(outp.clone(),nerd) enc = self.Embedding(outp) decin = torch.cat((enc,last),2) decout,(h,c) = self.dlstm(decin,(h,c)) last, vweight, _ = self.hierattn(decout,embs) scalar = torch.sigmoid(self.switch(h)) outs = torch.cat((decout,last),2) decoded = self.outlin(outs.contiguous().view(-1, self.args.hsz*2)) decoded = decoded.view(outs.size(0), outs.size(1), self.args.ntoks) decoded = torch.softmax(decoded,2) decoded[:,:,0].fill_(0) decoded[:,:,1].fill_(0) scalars = scalar.transpose(0,1) decoded = torch.mul(decoded,1-scalars.expand_as(decoded)) vweights = torch.mul(vweight,scalars.expand_as(vweight)) decoded = torch.cat([decoded,vweights],2) zero_vec = 1e-6*torch.ones_like(decoded) decoded += zero_vec decoded = decoded.log() scores, words = decoded.topk(dim=2,k=k) #scores = scores.transpose(0,1); words = words.transpose(0,1) if not beam: beam = Beam(words.squeeze(),scores.squeeze(),[h for i in range(beamsz)], [c for i in range(beamsz)],[last for i in range(beamsz)],beamsz,k) beam.endtok = self.endtok newembs = [] for a,x in embs: tmp = (x[0].repeat(len(beam.beam),1,1),x[1].repeat(len(beam.beam),1)) newembs.append((a,tmp)) embs = newembs else: if not beam.update(scores,words,h,c,last): break newembs = [] for a,x in embs: tmp = (x[0][:len(beam.beam),:,:],x[1][:len(beam.beam)]) newembs.append((a,tmp)) embs = newembs outp = beam.getwords() h = beam.geth() c = beam.getc() last = beam.getlast() return beam
def train_sent(self, sent): # take sent from corpus and update weight vector # according to this example self.model.update_perceptron_counter() # init state sent = [ROOT] + sent init_state = get_state(sent) # build gold tree gold_tree = get_tree(sent) beam = Beam(self.model.beam_size) top_valid_state = None beam.add(init_state) # loop n-1 step step = 0 # above check for i in xrange(len(sent) - 1): step += 1 # extend current beam beam, top_valid_state = self.extend_beam_for_train(beam, gold_tree) try: if not beam.has_element(top_valid_state.top()): self.update_paramaters(beam.top(), -1) self.update_paramaters(top_valid_state.top(), 1) break except Exception: raise if step == len(sent) - 1: top_beam = beam.top() predict_arcs = top_beam['arcs'] if not compare_arcs(predict_arcs, gold_tree): self.update_paramaters(top_beam, -1) self.update_paramaters(top_valid_state.top(), 1)
def train(self, sent): # update paramaters with one sent # ROOT token at begining of pending sent = [ROOT] + sent # oracle object to check valid action oracle = Oracle(sent) # gold_deps for full update gold_deps = self._build_gold(sent) # create start state init_state = self._get_state(sent) # create beam beam = Beam(self.model.beam_size) # add state to beam beam.add(init_state) # correct action with highest score at one step valid_action = None for step in range(len(sent) - 1): beam, valid_action = self._extend_beam(beam, oracle) # if beam not contain valid action in it, update if not beam.has_element(valid_action): beam_top = beam.top() self.model.update(beam_top, valid_action) break else: beam_top = beam.top() beam_deps = beam_top['deps'] # if final deps is not like gold_deps, do full update if not self._check_equal(gold_deps, beam_deps): self.model.update(beam_top, valid_action)
def fire(ai_settings, screen, ship, bullets, beams): # Create a new bullet and add it to the bullets group. if ship.charge(): new_beam = Beam(ai_settings, screen, ship) beams.add(new_beam) else: new_bullet = Bullet(ai_settings, screen, ship) bullets.add(new_bullet) ship.fire()
def fire_random_beam(ai_settings, screen, aliens, beams): """Fire a beam from aliens""" attack = random.choice(aliens.sprites()) if len(beams) < ai_settings.beams_limit and \ (ai_settings.beam_stamp is None or (abs(pygame.time.get_ticks() - ai_settings.beam_stamp) > ai_settings.beam_time)): new_beam = Beam(ai_settings, screen, attack) attack.fire_weapon() beams.add(new_beam)
class Iris(irc.IRCClient): nickname = irx.config.nickname realname = irx.config.realname username = irx.config.username def __init__(self): self.irx = Irx.Irx(self.sendLine, irx.config.nickname, irx.config.username, irx.config.realname) self.irx.loadPlugins("plugins") self.irx.buildCommandList() self.beam = Beam() def connectionMade(self): irc.IRCClient.connectionMade(self) def connectionLost(self): irc.IRCClient.connectionLost(self, reason) def signedOn(self): for channel in irx.config.channels: self.join(channel) def topicUpdated(self, user, channel, topic): f = open("data/topics/current_topic_%s.txt" % channel, "w+") f.write(topic) f.close() def privmsg(self, user, channel, data): if data.startswith("."): self.irx.doCommand(channel, user, data) else: if not data.startswith('%s:' % irx.config.nickname): if 'headsplitter' not in user: if data.count('.') > 1: data = data.split('.') for line in data: self.beam.addToChain(line) else: self.beam.addToChain(data) else: try: self.irx.send(channel, '%s: %s' % (user.split('!', 1)[0], self.beam.generateRandomText())) #self.irx.send(channel, '%s: %s' % (user.split('!', 1)[0], self.beam.generateText(data.split('%s:' % irx.config.nickname, 1)[1].strip()))) This is seeded with your message except IndexError: pass
def extend_beam_for_train(self, beam, gold_tree): """ :param beam: :param gold_tree: :return: """ new_beam = Beam(beam_size=self.model.beam_size) top_valid_state = Beam(beam_size=1) for state in beam: pending = state['pending'] prev_features = state['features'] prev_score = state['score'] arcs = state['arcs'] state_valid = state['valid'] for attachment_point in xrange(len(pending) - 1): # at this point you could create n new state local_features = features_extract(pending, arcs, attachment_point) # features extract funtion has not be built yet scores = self.model.get_scores(local_features) global_features = prev_features + local_features for cls_id, score in scores.iteritems(): action = get_action(attachment_point, cls_id, self.model.label_hash) # check if action is valid valid_action = False if state_valid: valid_action = check_valid_action( pending, arcs, action, gold_tree) # apply action to pending new_pending, new_arcs = apply_action(pending, arcs, action) # create new state if prev_score == float('-inf'): current_score = score else: current_score = prev_score + score new_state = get_state(new_pending, global_features, current_score, cls_id, new_arcs, valid_action) # add new state to beam new_beam.add(new_state) if valid_action: top_valid_state.add(new_state) return new_beam, top_valid_state
def generate_beams(self): n_beam = 30 for _ in range(n_beam): r = randint(4, self.__row - 10) c = randint(50, self.__col - 10) t = Beam(r, c, self) t.set_orientation(choice(["vert", "horiz", "diag"])) t.render(self.__buf) self.add_entity(t)
def test_beam_init(self): n1 = Node(0., 0., 0.) n2 = Node(10., 10., 0.) b1 = Beam(n1, n2) b1.properties['Area'] = 0.1 * 0.1 self.assertAlmostEqual(b1.length(), sqrt(200.)) self.assertAlmostEqual(b1.volume(), 0.01 * sqrt(200.)) self.assertTrue(b1.sizeOfEM() == 12)
def __init__(self, lon, lat, antpos, freqs, df=40e3, date=ephem.now(), driftMode=True, beam=Beam(mwabeam, [None, [0., 0.]])): self.driftMode = driftMode self.obs = ephem.Observer() self.lat = lat self.lon = lon self.obs.lat = str(lat) self.obs.lon = str(lon) self.obs.date = date self.antpos = antpos #convert from n-s,e-w coords to XYZ coords where Y points to -6 hours, X to 0 hours and Z along the earth's rotation axis. self.lst = np.degrees(float(repr(self.obs.sidereal_time()))) self.xyz = nsew2xyz(antpos, self.lst, lat) self.nant = self.xyz.shape[0] self.freqs = freqs df = df nf = len(freqs) self.delays = np.arange(-nf / 2, nf / 2) / (nf * df) self.nvis = (self.nant - 1) * self.nant / 2 self.model = np.zeros((len(freqs), self.nvis)).astype(complex) self.pcentre = np.array([self.lst, lat]) if (self.driftMode): self.nunique, self.unique_map, self.unique_uvw, self.uvw = self.getUnique( self.pcentre) # print self.uvw # print len(freqs),self.nunique self.model_true = np.zeros( (len(freqs), self.nunique)).astype(complex) # print self.unique_map self.modelspace = 'freq' self.data = np.zeros((len(freqs), self.nvis)).astype(complex) self.datastate = 'freq' #fifteen degrees at lowest frequency self.beam = beam self.bandpass = [ Bandpass(flatband, [1]) for mm in range(self.xyz.shape[0]) ] #instantiate all antennae to same bandpass
def beam_generate(self, batch, beam_size, k) : batch = batch.input encoder_output, context = self.encoder(batch[0], batch[1]) hidden = [] for i in range(len(context)) : each = context[i] hidden.append(torch.cat([each[0:each.size(0):2], each[1:each.size(0):2]], 2)) hx = hidden[0] cx = hidden[1] recent_token = torch.LongTensor(1, ).fill_(2).to(self.device) beam = None for i in range(1000) : embedded = self.decoder.embedding(recent_token.type(dtype = torch.long).to(self.device)) #(beam_size, embedding_size) embedded = embedded.unsqueeze(0).permute(1, 0, 2) output, (hx, cx) = self.decoder.rnn(embedded, (hx.contiguous(), cx.contiguous())) hx = hx.permute(1, 0, -1) cx = cx.permute(1, 0, -1) output = self.decoder.out(output.contiguous()) #(beam_size, 1, target_vocab_size) output = self.softmax(output) output[:, :, 0].fill_(0) output[:, :, 1].fill_(0) output[:, :, 2].fill_(0) decoded = output.log().to(self.device) scores, words = decoded.topk(dim = -1, k = k) #(beam_size, 1, k) (beam_size, 1, k) scores.to(self.device) words.to(self.device) if not beam : beam = Beam(words.squeeze(), scores.squeeze(), [hx] * beam_size, [cx] * beam_size, beam_size, k, self.decoder.output_vocab_size, self.device) beam.endtok = 5 beam.eostok = 3 else : if not beam.update(scores, words, hx, cx) : break recent_token = beam.getwords().view(-1) #(beam_size, ) hx = beam.get_h().permute(1, 0, -1) cx = beam.get_c().permute(1, 0, -1) #context = beam.get_context() return beam
def process_beams(self): self.beams = [] for p1 in self.players: for p2 in self.players: if p1.dist_to(p2.pos) < 120.0: beam = Beam() beam.pos1 = p1.pos beam.pos2 = p2.pos beam.damage = 3 self.beams.append(beam) # Make the beams take damage! for beam in self.beams: length = beam.length() for entity in self.entities: if line_circle_intersect(beam.pos1, beam.pos2, entity.pos, entity.radius): beam.make_damage(entity)
def parse_palkit(self, line): try: if line.strip() != "": parts = line.split(",") measure = int(parts[0].strip()) measurenotes = self.sort_measurenotes(measure) notes = [] note_parts = parts[1].split(":") for note in note_parts: try: notesort = int(note.strip()) except ValueError: raise CorruptedCompositionFileError( "Omituinen nuotti palkille") notes.append(measurenotes[notesort]) beam = Beam(notes) Composition.add_beam(self.comp, beam) return True except: print("Huono palkki")
def findReaction( b: Beam, p: Union[Beam, None] ) -> Tuple[Vector3, float]: # tuple float is the beam's angle v: Vector3 = Vector3(0, 0, 0) endFirst: bool for i in range(len(self.beams)): if b == self.beams[i][0]: break if len(b.start[1]) == 0: endFirst = False if b.start[0] != None: v = rotate(b.start[0].reaction, -self.beams[i][2]) elif len(b.end[1]) == 0: endFirst = True if b.end[0] != None: v = rotate(b.end[0].reaction, -self.beams[i][2]) elif p != None: if p in b.start[1]: endFirst = True for c in b.end[1]: r: Tuple[Vector3, float] = findReaction(c, b) v += rotate(r[0], r[1] - self.beams[i][2]) elif p in b.end[1]: endFirst = False for c in b.start[1]: r: Tuple[Vector3, float] = findReaction(c, b) v += rotate(r[0], r[1] - self.beams[i][2]) else: raise Exception('Cannot find parent!') else: raise Exception('Parent not given!') v = b.solve(v, self.beams[i][2], endFirst) solution[i] = b.stress return (v, self.beams[i][2])
def f_decode_text_beam(self, z, max_seq_len, n=4): if z is None: assert "z is none" batch_size = self.m_batch_size beam_size = self.m_beam_size ### hidden size: batch_size*hidden_size hidden = z ### hidden size: 1*batch_size*hidden_size hidden = hidden.unsqueeze(0) hidden_size = hidden.size()[2] ### hidden_beam: 1*(batch_size*beam_size)*hidden_size hidden_beam = hidden.repeat(1, beam_size, 1) ### beam: batch_size beam = [ Beam(beam_size, self.m_pad_idx, self.m_sos_idx, self.m_eos_idx, self.m_device) for k in range(batch_size) ] batch_idx = list(range(batch_size)) remaining_sents = batch_size print("max_seq_len", max_seq_len) for i in range(max_seq_len): ### input: 1*(beam_size*remain_size) input = torch.stack([ b.get_cur_state() for b in beam if not b.m_done ]).t().contiguous().view(1, -1).to(self.m_device) # print("input", input) # exit() ### input_emb: (remain_size*beam_size)*1*embed_size input_emb = self.m_network.m_embedding(input.transpose(1, 0)) ### output: (remain_size*beam_size)*1*hidden_size ### hidden_beam: 1*(remain_size*beam_size)*hidden_size output, hidden_beam = self.m_network.m_decoder_rnn( input_emb, hidden_beam) ### logits: (remain_size*beam_size)*voc_size logits = self.m_network.m_linear_output(output.squeeze(1)) ### pred_prob: (remain_size*beam_size)*voc_size pred_prob = F.log_softmax(logits, dim=-1) ### word_lk: remain_size*beam_size*voc_size word_lk = pred_prob.view(beam_size, remaining_sents, -1).transpose(0, 1).contiguous() active = [] for b in range(batch_size): if beam[b].m_done: continue idx = batch_idx[b] if not beam[b].advance(word_lk[idx]): active += [b] ### hidden_beam: 1*(remain_size*beam_size)*hidden_size ### b_hidden: 1*beam_size*1*hidden_size b_hidden = hidden_beam.view(-1, beam_size, remaining_sents, hidden_size)[:, :, idx] ### b_hidden: 1*beam_size*1*hidden_size b_hidden.copy_( b_hidden.index_select(1, beam[b].get_cur_origin())) if not active: break ### index of remaining sentences in last round active_idx = torch.LongTensor([batch_idx[k] for k in active]).to(self.m_device) ### re-index for remaining sentences batch_idx = {beam: idx for idx, beam in enumerate(active)} def update_active(t): ### t_tmp: beam_size*remain_size*hidden_size t_tmp = t.data.view(-1, remaining_sents, hidden_size) ### new_size = list(t.size()) new_size[-2] = new_size[-2] * len( active_idx) // remaining_sents ### new_t: beam_size*new_remain_size*hidden_size new_t = t_tmp.index_select(1, active_idx) ### new_t: beam_size*new_remain_size*hidden_size new_t = new_t.view(*new_size) new_t = torch.tensor(new_t).to(self.m_device) return new_t ### hidden_beam: 1*(new_remain_size*beam_size)*hidden_size hidden_beam = update_active(hidden_beam) remaining_sents = len(active) all_hyp, all_scores = [], [] n_best = 1 # for b in range(batch_size): # scores, ks = beam[b].sort_best() # all_scores += [scores[:n_best]] # hyps = zip(*[beam[b].get_hyp(k) for k in ks[:n_best]]) # all_hyp += [hyps] for b in range(batch_size): scores, ks = beam[b].sort_best() # print("scores", scores) all_scores += [scores[:n_best]] k = ks[:n_best] # print("k", k) hyps = beam[b].get_hyp(k) all_hyp += [hyps] return all_hyp, all_scores
def __init__(self): self.irx = Irx.Irx(self.sendLine, irx.config.nickname, irx.config.username, irx.config.realname) self.irx.loadPlugins("plugins") self.irx.buildCommandList() self.beam = Beam()
def __init__(self, inputfile=''): self.beam1 = Beam() self.beam2 = Beam() if inputfile is not '': self.readfrom(inputfile)
ConstantContinuousLoad(q, a, a+b), PointLoad(-F, a), PointLoad(-F, a+b) ] # reactions - list of unknown loads # All must have magnitude = 1, otherwise the results of # Beam.get_reactions would be wrong. reactions = [PointLoad(1, 0), PointLoad(1, a+b+c)] # Initialize the beam object. # For now we don't need the actual value of Jz since we are # going to compute the actual dimensions based on the values # of reaction forces. beam = Beam(loads, reactions, l = a+b+c, E = E, Jz = 1., ) Rs = beam.get_reactions() print('reactions:\n R_A = {:.2e}N\n R_B = {:.2e}N'.format(Rs[0], Rs[1])) ### computation and plots of bending force and moment ### n = 12*5+1 x = np.linspace(0, a+b+c, n) plt.plot(x, [beam.force(xi) for xi in x], '.-', label='force') Mo = np.array([beam.moment(xi) for xi in x]) plt.plot(x, Mo, '.-', label='moment') plt.legend(loc='best')