def choose_multi_label(labels, lang_model): longest = util.argmax(labels, scorer=lambda ngram: len(ngram)) if len(longest) > 3: best = util.argmax(bigrams.trigrams(longest), lambda ng: lang_model.lidstone(ng)) best = (best,) elif len(longest) == 3: best = longest best = (best,) elif len(longest) <= 2: # this is kinda shitty set of them .. would rather want all possible skip n-grams (O(N^2) of them?) z = [(tuple(x),) for x in labels] + bigrams.bigrams(labels) + bigrams.trigrams(labels) assert z z = [x for x in z if len(util.flatten(x)) <= 3] # sum is too weird # lexicographic ordering of the top-ranked sublabels in the multilabel def scorer(ngrams): scores = [lang_model.lidstone(ng) for ng in ngrams] if len(scores) < 3: scores += [0]*(3 - len(scores)) scores.sort(reverse=True) # print "SCORE %-30s %s" % (scores, ngrams) return scores z.sort(key= scorer, reverse=True) # print "RANKING",z best = z[0] else: assert False return best
def choose_multi_label(labels, lang_model): longest = util.argmax(labels, scorer=lambda ngram: len(ngram)) if len(longest) > 3: best = util.argmax(bigrams.trigrams(longest), lambda ng: lang_model.lidstone(ng)) best = (best, ) elif len(longest) == 3: best = longest best = (best, ) elif len(longest) <= 2: # this is kinda shitty set of them .. would rather want all possible skip n-grams (O(N^2) of them?) z = [(tuple(x), ) for x in labels ] + bigrams.bigrams(labels) + bigrams.trigrams(labels) assert z z = [x for x in z if len(util.flatten(x)) <= 3] # sum is too weird # lexicographic ordering of the top-ranked sublabels in the multilabel def scorer(ngrams): scores = [lang_model.lidstone(ng) for ng in ngrams] if len(scores) < 3: scores += [0] * (3 - len(scores)) scores.sort(reverse=True) # print "SCORE %-30s %s" % (scores, ngrams) return scores z.sort(key=scorer, reverse=True) # print "RANKING",z best = z[0] else: assert False return best
def viterbi(self): """Returns the viterbi decoded path.""" # TODO(kevintee): Return the viterbi decoded path (list of states) viterbi = [] forward_table = {} backpointers = {} states = self.theta.m.keys() for t in range(len(self.x)): for k in states: if t == 0: forward_table[k] = [log(self.theta.e[k][self.x[t]]) + \ log(self.theta.m[k])] backpointers[k] = [0] else: offset = max([forward_table[i][t - 1] for i in states]) forward_table[k].append(log(self.theta.e[k][self.x[t]]) + \ offset + log(max([e**(forward_table[i][t - 1] - offset) * \ self.theta.a[i][k] for i in states]))) backpointers[k].append(argmax([e**(forward_table[i][t - 1] - \ offset) * self.theta.a[i][k] for i in states])) pointer = None for t in reversed(range(len(self.x))): if t == len(self.x) - 1: values = [forward_table[i][t] for i in states] viterbi.append(states[argmax(values)]) pointer = backpointers[states[argmax(values)]][t] elif t > 0: viterbi = [states[pointer]] + viterbi pointer = backpointers[states[pointer]][t] elif t == 0: viterbi = [states[pointer]] + viterbi return viterbi
def _viterbi_decode(self, feats): """ viterbi 维特比解码 :param feats: :return: """ backpointers = [] # Initialize the viterbi variables in log space init_vvars = torch.full((1, self.tagset_size), -10000.) init_vvars[0][self.tag_to_ix[config.START_TAG]] = 0 # forward_var at step i holds the viterbi variables for step i-1 forward_var = init_vvars for feat in feats: bptrs_t = [] # holds the backpointers for this step viterbivars_t = [] # holds the viterbi variables for this step for next_tag in range(self.tagset_size): # next_tag_var[i] holds the viterbi variable for tag i at the # previous step, plus the score of transitioning # from tag i to next_tag. # We don't include the emission scores here because the max # does not depend on them (we add them in below) next_tag_var = forward_var + self.transitions[next_tag] best_tag_id = argmax(next_tag_var) bptrs_t.append(best_tag_id) viterbivars_t.append(next_tag_var[0][best_tag_id].view(1)) # Now add in the emission scores, and assign forward_var to the set # of viterbi variables we just computed forward_var = (torch.cat(viterbivars_t) + feat).view(1, -1) backpointers.append(bptrs_t) # Transition to STOP_TAG terminal_var = forward_var + self.transitions[self.tag_to_ix[ config.STOP_TAG]] best_tag_id = argmax(terminal_var) path_score = terminal_var[0][best_tag_id] # Follow the back pointers to decode the best path. best_path = [best_tag_id] for bptrs_t in reversed(backpointers): best_tag_id = bptrs_t[best_tag_id] best_path.append(best_tag_id) # Pop off the start tag (we dont want to return that to the caller) start = best_path.pop() assert start == self.tag_to_ix[config.START_TAG] # Sanity check best_path.reverse() return path_score, best_path
def knapsack(capacity: int, weights: List[int], values: List[int]) -> List[bool]: if len(weights) == 0: raise ValueError("Weights array must not be empty") if len(values) == 0: raise ValueError("Values array must not be empty") if len(weights) != len(values): raise ValueError( "Both weights and values arrays must have equal length") n = len(weights) table: List[List[int]] = [[0] * (capacity + 1) for _ in range(n + 1)] for i in range(1, n + 1): for j in range(1, capacity + 1): item = i - 1 remainder = j - weights[item] add_item = 0 if remainder >= 0: add_item = table[i - 1][remainder] + values[item] # decide whether to add item or not table[i][j] = max(table[i - 1][j], add_item) res: List[bool] = [False] * n i = n # start from the last item (last row) j = capacity while i > 0 and j > 0: col = [] for k in range(i + 1): # take the column up to the ith item col.append(table[k][j]) i = argmax(col) if table[i][ j] != 0: # pick this item because it increased the total value item = i - 1 res[item] = True j -= weights[item] i -= 1 return res
def test(args, builder): print('testing...') total_fine_correct = 0.0 total_coarse_correct = 0 for test_no in range(args.test_data_size): fine_correct = 0 # Generate a new test example length = random.randint(*args.test_length_range) sequence = random_sequence(length, args.source_alphabet_size) # Start building the computation graph for this sequence dynet.renew_cg() state = builder.initial_state(1) # Feed everything up to and including the separator symbol into the # model for symbol in sequence.input_sequence(): index = input_symbol_to_index(symbol) state = state.next([index], StackLSTMBuilder.INPUT_MODE) # Feed the rest of the sequence into the model and stop at the first # error for correct_symbol in sequence.output_sequence(): predicted_index = argmax(state.output().value()) predicted_symbol = output_index_to_symbol(predicted_index) if predicted_symbol == correct_symbol: fine_correct += 1 state = state.next([predicted_index], StackLSTMBuilder.OUTPUT_MODE) else: break fine_total = sequence.output_sequence_length() total_fine_correct += (fine_correct / fine_total) total_coarse_correct += (fine_correct == fine_total) fine_accuracy = total_fine_correct / args.test_data_size coarse_accuracy = total_coarse_correct / args.test_data_size print('fine accuracy: %0.2f' % fine_accuracy) print('coarse accuracy: %0.2f' % coarse_accuracy)
def _viterbi_decode(self, feats): batch_size, sent_len, _ = feats.size() feats = feats.transpose(0,1).transpose(1,2).contiguous() # it should finally with the size: sent_len * label_size * batch_size pointers = [] backpointers = [] # Initialize the viterbi variables in log space init_vvars = torch.Tensor(sent_len + 1, batch_size, self.label_size).fill_(0) if feats.is_cuda: init_vvars = init_vvars.cuda() forward_var = Variable(init_vvars) # pdb.set_trace() pointers = [] for i in range(sent_len): # label_size * batch_size viterbivars_t = [] bptr_s = [] for next_tag in range(self.label_size): #next_tag_var = Variable(torch.Tensor(1, self.label_size).fill_(0)) next_tag_var = None feat = feats[i, next_tag] emit_score = feat.view(batch_size, 1).expand(batch_size, self.label_size) if i == 0: # the first node don't have the transition score next_tag_var = forward_var[i] + emit_score else: trans_score = self.transitions[next_tag].view(1, self.label_size).expand(batch_size, self.label_size) next_tag_var = forward_var[i] + trans_score + emit_score # pdb.set_trace() best_ids, best_value = util.argmax_m(next_tag_var) bptr_s.append(best_ids) best_value = best_value.view(-1, 1) viterbivars_t.append(best_value) forward_var[i + 1] = torch.cat(viterbivars_t, 1).view(batch_size, self.label_size) pointers.append(bptr_s) # pdb.set_trace() # decode the pointers assert len(pointers) == sent_len assert len(pointers[0]) == self.label_size # should be batch_size * sent_len pointers = np.array(pointers) ret_label = [] for batch_id in range(batch_size): final_label = util.argmax(forward_var[-1, batch_id]) sent_labels = [] # the first state should always be zero seqs = pointers[1:,:, batch_id] f_ = final_label sent_labels.append(f_) for tok_ind in reversed(range(sent_len - 1)): f_ = seqs[tok_ind][f_] sent_labels.append(f_) # remember to reverse the labels ret_label.append(list(reversed(sent_labels))) return ret_label
def best_policy(mdp, U): """Given an MDP and a utility function U, determine the best policy, as a mapping from state to action. (Equation 17.4)""" pi = {} for s in mdp.states: pi[s] = argmax(mdp.actions(s), key=lambda a: expected_utility(a, s, U, mdp)) return pi
def subset_sum(capacity: int, weights: Set[int]) -> Set[int]: n = len(weights) w_list = list(weights) # table[i][j] is True if subset with sum j can be obtained with items [1..i] table: List[List[bool]] = [[False] * (capacity + 1) for _ in range(n + 1)] for i in range(n + 1): table[i][0] = True for i in range(1, n + 1): for j in range(1, capacity + 1): item = i - 1 remainder = j - w_list[item] add_item = remainder >= 0 and table[i - 1][remainder] table[i][j] = table[i - 1][j] or add_item res: Set[int] = set() i = n # start from the last item (last row) j = capacity while i > 0 and j > 0: col = [] for k in range(i + 1): # take the column up to the ith item col.append(table[k][j]) i = argmax(col) if table[i][j]: # pick this item w = w_list[i - 1] res.add(w) j -= w i -= 1 return res
def _viterbi_decode(self, feats): backpointers = [] # analogous to forward init_vvars = torch.Tensor(1, self.tagset_size).fill_(-10000.) init_vvars[0][self.tag_to_ix['<start>']] = 0 forward_var = init_vvars for feat in feats: next_tag_var = forward_var.view(1, -1).expand( self.tagset_size, self.tagset_size) + self.transitions _, bptrs_t = torch.max(next_tag_var, dim=1) bptrs_t = bptrs_t.squeeze().data.cpu().numpy() next_tag_var = next_tag_var.data.cpu().numpy() viterbivars_t = next_tag_var[range(len(bptrs_t)), bptrs_t] viterbivars_t = torch.FloatTensor(viterbivars_t) forward_var = viterbivars_t + feat backpointers.append(bptrs_t) terminal_var = forward_var + self.transitions[self.tag_to_ix['<stop>']] terminal_var.data[self.tag_to_ix['<stop>']] = -10000. terminal_var.data[self.tag_to_ix['<start>']] = -10000. best_tag_id = argmax(terminal_var.unsqueeze(0)) path_score = terminal_var[best_tag_id] best_path = [best_tag_id] for bptrs_t in reversed(backpointers): best_tag_id = bptrs_t[best_tag_id] best_path.append(best_tag_id) start = best_path.pop() assert start == self.tag_to_ix['<start>'] best_path.reverse() return path_score, best_path
def get_interpolants_bv( bvfmls: List[Tree], m: int, opt: SMTUtilOption, stat: statistics.Statistics) -> Tuple[List[str], List[str], List[Any]]: st = time.time() liafmls = [convert_bv2lia(fml, m) for fml in bvfmls] # print("checking") # for b, l in zip(bvfmls, liafmls): # assert_equal_bv(b, m, opt) # print("checked") stat.time_to_lia += time.time() - st withconstraints = [["and", p, get_range_constraints(get_variables(p), m)] for p in liafmls] # withconstraints = liafmls # lia_interpols = get_interpolants_lia(withconstraints) while True: try: lia_interpols = get_interpolants_lia(withconstraints, opt, stat) break except UnexpectedInterpolationError: logging.warning("Failed at interpolation") if not opt.expand_floor_in_inteprolation_error: raise UnexpectedInterpolationError() modsmods = [ find_subtrees_by_tags(["mod"], liafml) for liafml in liafmls ] mods = functools.reduce(list.__add__, modsmods) if not mods: raise UnexpectedInterpolationError() def get_divisor(x): assert x[0][0] == "mod" return int(x[0][2]) maxmod, _ = util.argmax(mods, get_divisor) logging.warning( f"{debug_print_list(maxmod[0])} is being replaced.") maxmod[1][maxmod[2]] = mod_to_floor(maxmod[0]) def fv(t): return {v: (0, m - 1) for v in get_variables(t)} def ft(t): reduced_t, replacing_floor = reduce_float_from_tree( t, fv(t), m, opt, "strategy1") processed_replacing_floor = substitute_tree( reduced_t, replacing_floor) return processed_replacing_floor withconstraints = [ft(t) for t in withconstraints] print("hoge") stat.num_interp_failure += 1 st = time.time() converteds = [convert_lia2bv(fml, m, opt, stat) for fml in lia_interpols] stat.time_from_lia += time.time() - st assert_valid_interpolant_bv(bvfmls, converteds, lia_interpols, liafmls, m, opt) return converteds, lia_interpols, withconstraints
def get_next_action(self, state, eps): if random.uniform(0, 1) < eps: return random.choice([ a for a, i in zip(self.env.action_space, self.action_mask) if i ]) state = torch.tensor(state, dtype=torch.float32, device=self.device) state = state.reshape(1, -1) values = self.action_decider(state) out = argmax(values[0], self.action_mask) return out
def greedy(q, s): """ Return pi*(s) based on a greedy strategy. >>> q = TabularQ([0,1,2,3],['b','c']) >>> q.set(0, 'b', 5) >>> q.set(0, 'c', 10) >>> q.set(1, 'b', 2) >>> greedy(q, 0) 'c' >>> greedy(q, 1) 'b' """ # Your code here return argmax(q.actions, lambda a: q.get(s, a))
def policy_iteration(mdp): """Solve an MDP by policy iteration [Figure 17.7]""" U = {s: 0 for s in mdp.states} pi = {s: random.choice(mdp.actions(s)) for s in mdp.states} while True: U = policy_evaluation(pi, U, mdp) unchanged = True for s in mdp.states: a = argmax(mdp.actions(s), key=lambda a: expected_utility(a, s, U, mdp)) if a != pi[s]: pi[s] = a unchanged = False if unchanged: return pi
def __call__(self, percept): s1, r1 = self.update_state(percept) Q, Nsa, s, a, r = self.Q, self.Nsa, self.s, self.a, self.r alpha, gamma, terminals = self.alpha, self.gamma, self.terminals, actions_in_state = self.actions_in_state if s in terminals: Q[s, None] = r1 if s is not None: Nsa[s, a] += 1 Q[s, a] += alpha(Nsa[s, a]) * ( r + gamma * max(Q[s1, a1] for a1 in actions_in_state(s1)) - Q[s, a]) if s in terminals: self.s = self.a = self.r = None else: self.s, self.r = s1, r1 self.a = argmax(actions_in_state(s1), key=lambda a1: self.f(Q[s1, a1], Nsa[s1, a1])) return self.a
def __init__(self, moments, origin): self.origin = origin # Model the ellipse on the component with the largest area moments = list(moments) m = moments[util.argmax(m.m00 for m in moments)] self.centre = (m.m10 / m.m00, m.m01 / m.m00) self.angle = 0.5 * math.atan2(2.0 * m.mu11, m.mu20 - m.mu02) def variance_at_angle(angle): s, c = math.sin(2.0 * angle), math.cos(2.0 * angle) nu11, nu02, nu20 = (x / m.m00 for x in (m.mu11, m.mu02, m.mu20)) return 0.5 * (nu20 + nu02 + c * (nu20 - nu02) + 2.0 * s * nu11) # Find the axis lengths up to a constant of proportionality. self.axes = tuple(variance_at_angle(x) ** 0.5 for x in (self.angle, self.angle + 0.5 * math.pi)) # Scale the axes so that the area of the resulting ellipse matches the measured area. scale_factor = math.sqrt(m.m00 / (math.pi * self.axes[0] * self.axes[1])) self.axes = tuple(scale_factor * x for x in self.axes)
def dominantPole(self): """ :returns: the pole with the largest magnitude """ return util.argmax(self.poles(), abs)
def greedy(q, s): # Your code here return argmax(q.actions, lambda a: q.get(s, a))
def get_best_action(self, state): possible_actions = self.get_possible_actions(state) get_q_value = lambda action: self.q_by_state_action.get((state, action), 0) return util.argmax(possible_actions, get_q_value)
def test_argmax(self): x = ["hoge", "hogetarou", "a", "hogeh"] res, resval = util.argmax(x, len) self.assertEqual((res, resval), ("hogetarou", 9))
def greedy(q, s): return argmax(q.actions, lambda a: q.get(s, a))
# transProbs[h1][h2] = p_trans(h2 | h1) # Estimate this from raw text (fully spuervised) transCounts = [[0 for h2 in range(K)] for h1 in range(K)] for i in range(1, len(rawText)): h1, h2 = rawText[i - 1], rawText[i] transCounts[h1][h2] += 1 transProbs = [util.normalize(counts) for counts in transCounts] print(transProbs[util.toInt('t')][util.toInt('e')]) print(transProbs[util.toInt('t')][util.toInt('g')]) # emissionProbs[h][e] = p_emit(e | h) emissionProbs = [[1.0 / K for e in range(K)] for h in range(K)] ### Run EM to learn the emission probabilities for t in range(200): # E-step # q[i][h] = P(H_i = h | E = observations) q = util.forwardBackward(observations, startProbs, transProbs, emissionProbs) print(t) print(util.toStrSeq([util.argmax(q_i) for q_i in q])) # M-step emissionCounts = [[0 for e in range(K)] for h in range(K)] for i in range(len(observations)): for h in range(K): emissionCounts[h][observations[i]] += q[i][h] emissionProbs = [util.normalize(counts) for counts in emissionCounts]
rawText = util.toIntSeq(util.readText('lm.train')) for i in range(len(rawText) - 1): h1 = rawText[i] h2 = rawText[i + 1] transitionCounts[h1][h2] += 1 transitionProbs = [util.normalize(transitionCounts[h1]) for h1 in range(K)] # emissionProbs[h][e] = p_emit(e | h) emissionProbs = [[1.0 / K for e in range(K)] for h in range(K)] ### Run EM observations = util.toIntSeq(util.readText('ciphertext')) for t in range(200): # E-step # q[i][h]: q_i(h) q = util.forwardBackward(observations, startProbs, transitionProbs, emissionProbs) # Printing the best guess print(util.toStrSeq([util.argmax(q[i]) for i in range(len(observations))])) print('') # M-step emissionCounts = [[0 for e in range(K)] for h in range(K)] for i in range(len(observations)): for h in range(K): emissionCounts[h][observations[i]] += q[i][h] emissionProbs = [util.normalize(emissionCounts[h]) for h in range(K)]
def CalculateLossForDaf(daf, fValidation=False, fRunning=False): dy.renew_cg() tagged_daf = {"words":[],"file":daf["file"]} daf = daf["words"] # add a bos before and after seq = ['*BOS*'] + list(' '.join([word for word, _, _, _ in daf])) + ['*BOS*'] # get all the char encodings for the daf char_embeds = [let_enc(let) for let in seq] # run it through the bilstm char_bilstm_outputs = bilstm(char_embeds) # now iterate and get all the separate word representations by concatenating the bilstm output # before and after the word word_bilstm_outputs = [] iLet_start = 0 for iLet, char in enumerate(seq): # if it is a bos, check if it's at the end of the sequence if char == '*BOS*': if iLet + 1 == len(seq): char = ' ' else: continue # if we are at a space, take this bilstm output and the one at the letter start if char == ' ': cur_word_bilstm_output = dy.concatenate([char_bilstm_outputs[iLet_start], char_bilstm_outputs[iLet]]) # add it in word_bilstm_outputs.append(cur_word_bilstm_output) # set the iLet_start ocunter to here iLet_start = iLet # safe-check, make sure word bilstm outputs length is the same as the daf if len(word_bilstm_outputs) != len(daf): log_message('Size mismatch!! word_bilstm_outputs: ' + str(len(word_bilstm_outputs)) + ', daf: ' + str(len(daf))) s_0 = prev_pos_lstm.initial_state() beam = [(['*BOS*'],1.0,s_0,[],0.0,0.0,0.0,0.0,0.0,[])] # seq, prob, lstm_state, losses, class_prec, class_items, pos_prec, rough_pos_prec, pos_items, confidences i = 0 for (word, gold_word_class, gold_word_pos, gold_word_lang), bilstm_output in zip(daf, word_bilstm_outputs): should_backprop = gold_word_class == 1 new_hypos = [] for hypo in beam: seq, hyp_prob, hyp_state, losses, class_prec, class_items, pos_prec, rough_pos_prec, pos_items, confidences = hypo new_seq = seq[:] new_losses = losses[:] new_confidences = confidences[:] last_pos = seq[-1] next_hyp_state = hyp_state.add_input(pos_enc(last_pos)) # create the mlp input, a concatenate of the bilstm output and of the prev pos output mlp_input = dy.concatenate([bilstm_output, next_hyp_state.output()]) # run through the class mlp class_mlp_output = class_mlp(mlp_input) predicted_word_class = np.argmax(class_mlp_output.npvalue()) new_confidences.append(np.max(class_mlp_output.npvalue()) / np.sum(class_mlp_output.npvalue())) # prec if should_backprop: class_prec += 1 if predicted_word_class == gold_word_class else 0 class_items += 1 # if we aren't doing validation, calculate the loss if not fValidation and not fRunning: if should_backprop: new_losses.append(-dy.log(dy.pick(class_mlp_output, gold_word_class))) word_class_ans = gold_word_class # otherwise, set the answer to be the argmax else: word_class_ans = predicted_word_class # if the word_class answer is 1, do the pos! # alternatively, if validating and it's aramic, do the pos! if word_class_ans or (fValidation and gold_word_lang) or (fRunning and gold_word_lang): # run the pos mlp output pos_mlp_output = pos_mlp(mlp_input) try: temp_pos_array = pos_mlp_output.npvalue() possible_pos_array = np.zeros(temp_pos_array.shape) pos_list = pos_hashtable[word] # pos_list.add('') #concat 'unknown' as possible pos possible_pos_indices = [pos_vocab[temp_pos] for temp_pos in pos_list] possible_pos_array[possible_pos_indices] = temp_pos_array[possible_pos_indices] except KeyError: possible_pos_array = pos_mlp_output.npvalue() # if fValidation: # possible_pos_array[pos_vocab['']] = 0.0 # don't allow validation to guess UNK b/c it never trained against that TODO this makes sense, right? poss_pos_sum = np.sum(possible_pos_array) for iprob, prob in enumerate(possible_pos_array): new_seq = seq[:] temp_picked_pos = pos_vocab.getItem(iprob) temp_confidence = possible_pos_array[iprob] / poss_pos_sum new_confidences[-1] = temp_confidence # overwrite class confidence new_pos_prec = pos_prec new_pos_items = pos_items new_rough_pos_prec = rough_pos_prec if should_backprop: new_pos_prec += 1 if temp_picked_pos == gold_word_pos else 0 new_rough_pos_prec += 1 if len(temp_picked_pos) > 0 and temp_picked_pos[0] == gold_word_pos[ 0] else 0 # you got at least the rough pos right new_pos_items += 1 if not fValidation and not fRunning: if should_backprop: new_losses.append( -dy.log(dy.pick(pos_mlp_output, pos_vocab[gold_word_pos]))) new_seq += [temp_picked_pos] new_prob = hyp_prob + math.log(prob) if prob != 0 else hyp_prob + math.log(1E-10) # which is log(0.00000001) or something like that new_hypos += [(new_seq, new_prob, next_hyp_state, new_losses, class_prec, class_items, new_pos_prec, new_rough_pos_prec, new_pos_items, new_confidences)] else: # assume prob is 1. It's really good at predicting hebrew / aramaic new_seq = seq[:] new_seq += [''] new_prob = hyp_prob new_hypos += [(new_seq, new_prob, next_hyp_state, new_losses, class_prec, class_items, pos_prec, rough_pos_prec, pos_items, new_confidences)] # pick the best hypos new_probs = [p for (s, p, r, l, cp, ci, pp, rpp, pi, c) in new_hypos] argmax_indices = util.argmax(new_probs, n=beam_width) if type(argmax_indices) == int: argmax_indices = [argmax_indices] beam = [new_hypos[l] for l in argmax_indices] i += 1 correct_answer_in_beam = False for max_ind in argmax_indices: if new_hypos[max_ind][0][-1] == gold_word_pos: correct_answer_in_beam = True break if not correct_answer_in_beam and not fValidation and not fRunning and with_early_stop: # early stop break final_probs = [p for (s, p, r, l, cp, ci, pp, rpp, pi, c) in beam] argmax_index = util.argmax(final_probs) final_seq, prob, lstm_state, all_losses, class_prec, class_items, pos_prec, rough_pos_prec, pos_items, confidences = beam[argmax_index] for (word, gold_word_class, gold_word_pos, gold_word_lang), pred, conf in zip(daf, final_seq[1:], confidences): # VERY IMPORTANT. final_seq is off-by-one b/c we inited it with BOS tagged_daf['words'].append({"word":word,"gold_pos":gold_word_pos,"gold_class":gold_word_class,"predicted":pred,"confidence":conf,"lang":gold_word_lang}) should_backprop = gold_word_class == 1 if should_backprop: pos_conf_matrix(pos_vocab[pred], pos_vocab[gold_word_pos]) if fRunning: return tagged_daf pos_prec = pos_prec / pos_items if pos_items > 0 else None rough_pos_prec = rough_pos_prec / pos_items if pos_items > 0 else None class_prec = class_prec / class_items if class_items > 0 else None if fValidation: return class_prec, pos_prec,tagged_daf, rough_pos_prec total_loss = dy.esum(all_losses) if len(all_losses) > 0 else None return total_loss, class_prec, pos_prec, rough_pos_prec
def maxProbElt(self): """ :returns: The element in this domain with maximum probability """ return util.argmax(self.support(), self.prob)
def dominantPole(self): """ @returns: the pole with the largest magnitude """ return util.argmax(self.poles(), abs)
def maxProbElt(self): """ @returns: The element in this domain with maximum probability """ return util.argmax(self.support(), self.prob)
import random
def ours_evaluate(config, env, ep, house, epind, model, visualize, model_config): hn, floor, class_label, goal_dist, pos, rot = ep if config.SCORE == 'detector' or config.COMBINE_DETECTOR: predictor = get_predictor() predictor_class_index = predictor.metadata.thing_classes.index( class_label) rng = random.Random() rng.seed(config.SEED) if goal_dist == float('inf'): return np.array([]) if config.STOP else 0 class_index = class_labels.index(class_label) def model_score(ims): torch_ims = util.torch.to_imgnet(torch.tensor(ims).to('cuda')) with torch.no_grad(): return model(torch_ims.unsqueeze(0))[0, class_index, :].max().item() # compute the frame score combined with detector def score(ims): sc = model_score(ims['rgb']) if config.COMBINE_DETECTOR: size = ims['rgb'].shape[1] left_lim, right_lim = int(size / 3), int(size * 2 / 3) im = ims['rgb'][0] if len(ims['rgb']) == 4 else ims['rgb'] boxes, scores = get_scores(predictor, im, predictor_class_index) if len(scores) > 0 and scores.max() > config.CONFIDENCE_THRESHOLD: box = boxes[scores.argmax()] if box[0] <= right_lim or box[2] >= left_lim: if len(ims['rgb']) == 4: ims['rgb'][0] = draw_box(ims['rgb'][0], box, scores.max().item()) else: ims['rgb'] = draw_box(ims['rgb'], box, scores.max().item()) sc += (scores.max().item() + 1) return sc def output(): print(f"SPL: {spl}: {goal_dist}/{dist_traveled}") if config.SLAM and visualize: planner.write_combined( f'%04d_{class_label}-%dm-spl%.2f-steps%d' % (epind, int(goal_dist), spl, agent_steps_taken)) # np.save(f'data_dump/good_trajectory{epind}',np.array(log)) return np.array(log) if config.STOP else spl locs = house.object_locations_for_habitat_dest all_goals = [locs[k] for k in sorted(locs.keys())] from habitat.utils.visualizations import maps top_down_map = maps.get_topdown_map(env.env.sim, map_resolution=(map_resolution, map_resolution)) rrange, crange = util.habitat.crop_range(top_down_map) point_min = util.habitat.from_grid([rrange[0], crange[0]], map_resolution, 0) point_max = util.habitat.from_grid([rrange[1], crange[1]], map_resolution, 0) max_dim = np.abs(point_max - point_min).max() out_dir = f'{config.VIDEO_LOCATION}/{name_from_config(config)}' util.ensure_folders(out_dir, True) planner = DepthMapperAndPlanner(dt=30, out_dir=out_dir, map_size_cm=max_dim * 230, mark_locs=True, close_small_openings=True, log_visualization=visualize) polygons = relevant_objects(env.pos, house.objects[class_label]) planner._reset(goal_dist, global_goals=polygons, start_pos=env.pos, start_ang=env.angle) openlist = [] visited = [] dist_traveled = 0 log = [] spl = 0 agent_steps_taken = 0 full_log = [] episode_ims = [env.get_observation()] no_move = False def semantic_reasoning(): # log for visualizations planner.log_reasoning() images = [] display_values = [] for _ in range(NUM_ROTATIONS): ims, _, _, _ = env.step(1) loc = [*planner.pos_to_loc(env.pos), env.angle] planner.add_observation(ims['depth'] * 1000, loc) dest = check_movement(config, env, env.angle, planner=planner, rng=rng) sc = score(ims) # for visualizations images.append(ims) display_values.append(sc) if dest is not None: openlist.append((sc, dest)) if visualize and config.SLAM: ims_to_render = [ e['rgb'][0] if len(e['rgb'].shape) == 4 else e['rgb'] for e in images ] current_pan = join_images( ims_to_render, -np.array(display_values), bl_text='Predicted Values', br_text=f'Object Class: {class_label.title()}') planner.set_current_pan(current_pan) macro_steps = 50 if config.SLAM else 30 print("goals ", env.goals) # initial steps to scan env and choose dest semantic_reasoning() agent_steps_taken += NUM_ROTATIONS for macro_step_num in range(macro_steps): print(agent_steps_taken) if config.BACKTRACK_REJECTION and len(visited) > 0: vis_stack = np.stack(visited) def reject(point): dists = np.linalg.norm((vis_stack - point)[:, [0, 2]], axis=1) return (dists < (success_distance - 0.1)).sum() > 0 openlist = [e for e in openlist if not reject(e[1])] def maxfunc(x): s, d = x dist = np.linalg.norm(env.pos - d) return s + config.CONSISTENCY_WEIGHT * max(10 - dist, 0) / 10 if len(openlist) == 0: print("openlist exhausted") if visualize: planner.write_combined() return output() ind, (sc, next_pos), _ = util.argmax(openlist, maxfunc) openlist.pop(ind) original_openlist = openlist.copy() # remove points which we cannot move toward, with an exception # for the first step due to the initilization process dist_est = planner.fmmDistance(next_pos) while not planner.action_toward(next_pos): if len(openlist) == 0: print("openlist exhausted fmm") if visualize: planner.write_combined() return output() ind, (sc, next_pos), _ = util.argmax(openlist, maxfunc) openlist.pop(ind) dist_est = planner.fmmDistance(next_pos) print('score of', sc) if visualize and config.SLAM: planner.set_current_open(openlist) obs = env.get_observation() planner.set_goal(next_pos) goal_reached = False # 6 for initial rotation, and 2x distance*4 to # account for 1 rotation per forward step on average step_estimate = math.ceil(2 * (dist_est / 0.25) + 6) cur_dist_est = dist_est for step in range(step_estimate): new_dist_est = planner.fmmDistance(next_pos) # replan if the estimated distance jumps up too much if new_dist_est > cur_dist_est + 0.1: print('replan') break cur_dist_est = new_dist_est action = planner.get_action_toward(next_pos) print('action: ', action) if action == 3: print('subgoal reached') break before_pos = env.pos obs, _, _, _ = env.step(action) if action == 0: dist_traveled += 0.25 planner.pos_to_loc(env.pos) planner.log_act(obs, env.pos, env.angle, action) episode_ims.append(obs) visited.append(env.pos) log.append([ env.pos, env.rot, dist_traveled, env.distance_to_goal(), step == 0 ]) agent_steps_taken += 1 if env._dist_to_goal( env.pos) < success_distance and not config.STOP: spl = min(goal_dist / (dist_traveled + 1e-5), 1) return output() if agent_steps_taken >= MAX_STEPS: return output() semantic_reasoning() agent_steps_taken += NUM_ROTATIONS if agent_steps_taken >= MAX_STEPS: return output() return output()